/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc

Bug Summary

File:	build-llvm/tools/clang/include/clang/AST/Attrs.inc
Warning:	line 4718, column 5 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 SemaDeclObjC.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~svn338205/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn338205/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn338205/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/x86_64-linux-gnu/c++/8 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/8/../../../../include/c++/8/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/lib/gcc/x86_64-linux-gnu/8/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-class-memaccess -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn338205/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-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-07-29-043837-17923-1 -x c++ /build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp -faddrsig

/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp

→

1//===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===//
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 semantic analysis for Objective C declarations.
11//
12//===----------------------------------------------------------------------===//

14#include "TypeLocBuilder.h"
15#include "clang/AST/ASTConsumer.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/ASTMutationListener.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/Expr.h"
20#include "clang/AST/ExprObjC.h"
21#include "clang/AST/RecursiveASTVisitor.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Sema/DeclSpec.h"
24#include "clang/Sema/Lookup.h"
25#include "clang/Sema/Scope.h"
26#include "clang/Sema/ScopeInfo.h"
27#include "clang/Sema/SemaInternal.h"
28#include "llvm/ADT/DenseMap.h"
29#include "llvm/ADT/DenseSet.h"

31using namespace clang;

33/// Check whether the given method, which must be in the 'init'
34/// family, is a valid member of that family.
35///
36/// \param receiverTypeIfCall - if null, check this as if declaring it;
37///   if non-null, check this as if making a call to it with the given
38///   receiver type
39///
40/// \return true to indicate that there was an error and appropriate
41///   actions were taken
42bool Sema::checkInitMethod(ObjCMethodDecl *method,
                         QualType receiverTypeIfCall) {
if (method->isInvalidDecl()) return true;

// This castAs is safe: methods that don't return an object
// pointer won't be inferred as inits and will reject an explicit
// objc_method_family(init).

// We ignore protocols here.  Should we?  What about Class?

const ObjCObjectType *result =
    method->getReturnType()->castAs<ObjCObjectPointerType>()->getObjectType();

if (result->isObjCId()) {
  return false;
} else if (result->isObjCClass()) {
  // fall through: always an error
} else {
  ObjCInterfaceDecl *resultClass = result->getInterface();
  assert(resultClass && "unexpected object type!")(static_cast <bool> (resultClass && "unexpected object type!"
) ? void (0) : __assert_fail ("resultClass && \"unexpected object type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 61, __extension__ __PRETTY_FUNCTION__));

  // It's okay for the result type to still be a forward declaration
  // if we're checking an interface declaration.
  if (!resultClass->hasDefinition()) {
    if (receiverTypeIfCall.isNull() &&
        !isa<ObjCImplementationDecl>(method->getDeclContext()))
      return false;

  // Otherwise, we try to compare class types.
  } else {
    // If this method was declared in a protocol, we can't check
    // anything unless we have a receiver type that's an interface.
    const ObjCInterfaceDecl *receiverClass = nullptr;
    if (isa<ObjCProtocolDecl>(method->getDeclContext())) {
      if (receiverTypeIfCall.isNull())
        return false;

      receiverClass = receiverTypeIfCall->castAs<ObjCObjectPointerType>()
        ->getInterfaceDecl();

      // This can be null for calls to e.g. id<Foo>.
      if (!receiverClass) return false;
    } else {
      receiverClass = method->getClassInterface();
      assert(receiverClass && "method not associated with a class!")(static_cast <bool> (receiverClass && "method not associated with a class!"
) ? void (0) : __assert_fail ("receiverClass && \"method not associated with a class!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 86, __extension__ __PRETTY_FUNCTION__));
    }

    // If either class is a subclass of the other, it's fine.
    if (receiverClass->isSuperClassOf(resultClass) ||
        resultClass->isSuperClassOf(receiverClass))
      return false;
  }
}

SourceLocation loc = method->getLocation();

// If we're in a system header, and this is not a call, just make
// the method unusable.
if (receiverTypeIfCall.isNull() && getSourceManager().isInSystemHeader(loc)) {
  method->addAttr(UnavailableAttr::CreateImplicit(Context, "",
                    UnavailableAttr::IR_ARCInitReturnsUnrelated, loc));
  return true;
}

// Otherwise, it's an error.
Diag(loc, diag::err_arc_init_method_unrelated_result_type);
method->setInvalidDecl();
return true;
110}

112/// Issue a warning if the parameter of the overridden method is non-escaping
113/// but the parameter of the overriding method is not.
114static bool diagnoseNoescape(const ParmVarDecl *NewD, const ParmVarDecl *OldD,
                           Sema &S) {
if (OldD->hasAttr<NoEscapeAttr>() && !NewD->hasAttr<NoEscapeAttr>()) {
  S.Diag(NewD->getLocation(), diag::warn_overriding_method_missing_noescape);
  S.Diag(OldD->getLocation(), diag::note_overridden_marked_noescape);
  return false;
}

return true;
123}

125/// Produce additional diagnostics if a category conforms to a protocol that
126/// defines a method taking a non-escaping parameter.
127static void diagnoseNoescape(const ParmVarDecl *NewD, const ParmVarDecl *OldD,
                           const ObjCCategoryDecl *CD,
                           const ObjCProtocolDecl *PD, Sema &S) {
if (!diagnoseNoescape(NewD, OldD, S))
  S.Diag(CD->getLocation(), diag::note_cat_conform_to_noescape_prot)
      << CD->IsClassExtension() << PD
      << cast<ObjCMethodDecl>(NewD->getDeclContext());
134}

136void Sema::CheckObjCMethodOverride(ObjCMethodDecl *NewMethod, 
                                 const ObjCMethodDecl *Overridden) {
if (Overridden->hasRelatedResultType() && 
    !NewMethod->hasRelatedResultType()) {
  // This can only happen when the method follows a naming convention that
  // implies a related result type, and the original (overridden) method has
  // a suitable return type, but the new (overriding) method does not have
  // a suitable return type.
  QualType ResultType = NewMethod->getReturnType();
  SourceRange ResultTypeRange = NewMethod->getReturnTypeSourceRange();
  
  // Figure out which class this method is part of, if any.
  ObjCInterfaceDecl *CurrentClass 
    = dyn_cast<ObjCInterfaceDecl>(NewMethod->getDeclContext());
  if (!CurrentClass) {
    DeclContext *DC = NewMethod->getDeclContext();
    if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(DC))
      CurrentClass = Cat->getClassInterface();
    else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(DC))
      CurrentClass = Impl->getClassInterface();
    else if (ObjCCategoryImplDecl *CatImpl
             = dyn_cast<ObjCCategoryImplDecl>(DC))
      CurrentClass = CatImpl->getClassInterface();
  }
  
  if (CurrentClass) {
    Diag(NewMethod->getLocation(), 
         diag::warn_related_result_type_compatibility_class)
      << Context.getObjCInterfaceType(CurrentClass)
      << ResultType
      << ResultTypeRange;
  } else {
    Diag(NewMethod->getLocation(), 
         diag::warn_related_result_type_compatibility_protocol)
      << ResultType
      << ResultTypeRange;
  }
  
  if (ObjCMethodFamily Family = Overridden->getMethodFamily())
    Diag(Overridden->getLocation(), 
         diag::note_related_result_type_family)
      << /*overridden method*/ 0
      << Family;
  else
    Diag(Overridden->getLocation(), 
         diag::note_related_result_type_overridden);
}

if ((NewMethod->hasAttr<NSReturnsRetainedAttr>() !=
     Overridden->hasAttr<NSReturnsRetainedAttr>())) {
  Diag(NewMethod->getLocation(),
       getLangOpts().ObjCAutoRefCount
           ? diag::err_nsreturns_retained_attribute_mismatch
           : diag::warn_nsreturns_retained_attribute_mismatch)
      << 1;
  Diag(Overridden->getLocation(), diag::note_previous_decl) << "method";
}
if ((NewMethod->hasAttr<NSReturnsNotRetainedAttr>() !=
     Overridden->hasAttr<NSReturnsNotRetainedAttr>())) {
  Diag(NewMethod->getLocation(),
       getLangOpts().ObjCAutoRefCount
           ? diag::err_nsreturns_retained_attribute_mismatch
           : diag::warn_nsreturns_retained_attribute_mismatch)
      << 0;
  Diag(Overridden->getLocation(), diag::note_previous_decl)  << "method";
}

ObjCMethodDecl::param_const_iterator oi = Overridden->param_begin(),
                                     oe = Overridden->param_end();
for (ObjCMethodDecl::param_iterator ni = NewMethod->param_begin(),
                                    ne = NewMethod->param_end();
     ni != ne && oi != oe; ++ni, ++oi) {
  const ParmVarDecl *oldDecl = (*oi);
  ParmVarDecl *newDecl = (*ni);
  if (newDecl->hasAttr<NSConsumedAttr>() !=
      oldDecl->hasAttr<NSConsumedAttr>()) {
    Diag(newDecl->getLocation(),
         getLangOpts().ObjCAutoRefCount
             ? diag::err_nsconsumed_attribute_mismatch
             : diag::warn_nsconsumed_attribute_mismatch);
    Diag(oldDecl->getLocation(), diag::note_previous_decl) << "parameter";
  }

  diagnoseNoescape(newDecl, oldDecl, *this);
}
221}

223/// Check a method declaration for compatibility with the Objective-C
224/// ARC conventions.
225bool Sema::CheckARCMethodDecl(ObjCMethodDecl *method) {
ObjCMethodFamily family = method->getMethodFamily();
switch (family) {
21
←
Control jumps to 'case OMF_new:'  at line 270→
case OMF_None:
case OMF_finalize:
case OMF_retain:
case OMF_release:
case OMF_autorelease:
case OMF_retainCount:
case OMF_self:
case OMF_initialize:
case OMF_performSelector:
  return false;

case OMF_dealloc:
  if (!Context.hasSameType(method->getReturnType(), Context.VoidTy)) {
    SourceRange ResultTypeRange = method->getReturnTypeSourceRange();
    if (ResultTypeRange.isInvalid())
      Diag(method->getLocation(), diag::err_dealloc_bad_result_type)
          << method->getReturnType()
          << FixItHint::CreateInsertion(method->getSelectorLoc(0), "(void)");
    else
      Diag(method->getLocation(), diag::err_dealloc_bad_result_type)
          << method->getReturnType()
          << FixItHint::CreateReplacement(ResultTypeRange, "void");
    return true;
  }
  return false;
    
case OMF_init:
  // If the method doesn't obey the init rules, don't bother annotating it.
  if (checkInitMethod(method, QualType()))
    return true;

  method->addAttr(NSConsumesSelfAttr::CreateImplicit(Context));

  // Don't add a second copy of this attribute, but otherwise don't
  // let it be suppressed.
  if (method->hasAttr<NSReturnsRetainedAttr>())
    return false;
  break;

case OMF_alloc:
case OMF_copy:
case OMF_mutableCopy:
case OMF_new:
  if (method->hasAttr<NSReturnsRetainedAttr>() ||
22
←
Taking false branch→
      method->hasAttr<NSReturnsNotRetainedAttr>() ||
      method->hasAttr<NSReturnsAutoreleasedAttr>())
    return false;
  break;
23
←
 Execution continues on line 278→
}

method->addAttr(NSReturnsRetainedAttr::CreateImplicit(Context));
24
←
Calling 'NSReturnsRetainedAttr::CreateImplicit'→
return false;
280}

282static void DiagnoseObjCImplementedDeprecations(Sema &S, const NamedDecl *ND,
                                              SourceLocation ImplLoc) {
if (!ND)
  return;
bool IsCategory = false;
StringRef RealizedPlatform;
AvailabilityResult Availability = ND->getAvailability(
    /*Message=*/nullptr, /*EnclosingVersion=*/VersionTuple(),
    &RealizedPlatform);
if (Availability != AR_Deprecated) {
  if (isa<ObjCMethodDecl>(ND)) {
    if (Availability != AR_Unavailable)
      return;
    if (RealizedPlatform.empty())
      RealizedPlatform = S.Context.getTargetInfo().getPlatformName();
    // Warn about implementing unavailable methods, unless the unavailable
    // is for an app extension.
    if (RealizedPlatform.endswith("_app_extension"))
      return;
    S.Diag(ImplLoc, diag::warn_unavailable_def);
    S.Diag(ND->getLocation(), diag::note_method_declared_at)
        << ND->getDeclName();
    return;
  }
  if (const auto *CD = dyn_cast<ObjCCategoryDecl>(ND)) {
    if (!CD->getClassInterface()->isDeprecated())
      return;
    ND = CD->getClassInterface();
    IsCategory = true;
  } else
    return;
}
S.Diag(ImplLoc, diag::warn_deprecated_def)
    << (isa<ObjCMethodDecl>(ND)
            ? /*Method*/ 0
            : isa<ObjCCategoryDecl>(ND) || IsCategory ? /*Category*/ 2
                                                      : /*Class*/ 1);
if (isa<ObjCMethodDecl>(ND))
  S.Diag(ND->getLocation(), diag::note_method_declared_at)
      << ND->getDeclName();
else
  S.Diag(ND->getLocation(), diag::note_previous_decl)
      << (isa<ObjCCategoryDecl>(ND) ? "category" : "class");
325}

327/// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
328/// pool.
329void Sema::AddAnyMethodToGlobalPool(Decl *D) {
ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);
  
// If we don't have a valid method decl, simply return.
if (!MDecl)
  return;
if (MDecl->isInstanceMethod())
  AddInstanceMethodToGlobalPool(MDecl, true);
else
  AddFactoryMethodToGlobalPool(MDecl, true);
339}

341/// HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer
342/// has explicit ownership attribute; false otherwise.
343static bool
344HasExplicitOwnershipAttr(Sema &S, ParmVarDecl *Param) {
QualType T = Param->getType();

if (const PointerType *PT = T->getAs<PointerType>()) {
  T = PT->getPointeeType();
} else if (const ReferenceType *RT = T->getAs<ReferenceType>()) {
  T = RT->getPointeeType();
} else {
  return true;
}

// If we have a lifetime qualifier, but it's local, we must have 
// inferred it. So, it is implicit.
return !T.getLocalQualifiers().hasObjCLifetime();
358}

360/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible
361/// and user declared, in the method definition's AST.
362void Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {
assert((getCurMethodDecl() == nullptr) && "Methodparsing confused")(static_cast <bool> ((getCurMethodDecl() == nullptr) &&
 "Methodparsing confused") ? void (0) : __assert_fail ("(getCurMethodDecl() == nullptr) && \"Methodparsing confused\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 363, __extension__ __PRETTY_FUNCTION__));
ObjCMethodDecl *MDecl = dyn_cast_or_null<ObjCMethodDecl>(D);

// If we don't have a valid method decl, simply return.
if (!MDecl)
  return;

QualType ResultType = MDecl->getReturnType();
if (!ResultType->isDependentType() && !ResultType->isVoidType() &&
    !MDecl->isInvalidDecl() &&
    RequireCompleteType(MDecl->getLocation(), ResultType,
                        diag::err_func_def_incomplete_result))
  MDecl->setInvalidDecl();

// Allow all of Sema to see that we are entering a method definition.
PushDeclContext(FnBodyScope, MDecl);
PushFunctionScope();

// Create Decl objects for each parameter, entrring them in the scope for
// binding to their use.

// Insert the invisible arguments, self and _cmd!
MDecl->createImplicitParams(Context, MDecl->getClassInterface());

PushOnScopeChains(MDecl->getSelfDecl(), FnBodyScope);
PushOnScopeChains(MDecl->getCmdDecl(), FnBodyScope);

// The ObjC parser requires parameter names so there's no need to check.
CheckParmsForFunctionDef(MDecl->parameters(),
                         /*CheckParameterNames=*/false);

// Introduce all of the other parameters into this scope.
for (auto *Param : MDecl->parameters()) {
  if (!Param->isInvalidDecl() &&
      getLangOpts().ObjCAutoRefCount &&
      !HasExplicitOwnershipAttr(*this, Param))
    Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) <<
          Param->getType();
  
  if (Param->getIdentifier())
    PushOnScopeChains(Param, FnBodyScope);
}

// In ARC, disallow definition of retain/release/autorelease/retainCount
if (getLangOpts().ObjCAutoRefCount) {
  switch (MDecl->getMethodFamily()) {
  case OMF_retain:
  case OMF_retainCount:
  case OMF_release:
  case OMF_autorelease:
    Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def)
      << 0 << MDecl->getSelector();
    break;

  case OMF_None:
  case OMF_dealloc:
  case OMF_finalize:
  case OMF_alloc:
  case OMF_init:
  case OMF_mutableCopy:
  case OMF_copy:
  case OMF_new:
  case OMF_self:
  case OMF_initialize:
  case OMF_performSelector:
    break;
  }
}

// Warn on deprecated methods under -Wdeprecated-implementations,
// and prepare for warning on missing super calls.
if (ObjCInterfaceDecl *IC = MDecl->getClassInterface()) {
  ObjCMethodDecl *IMD = 
    IC->lookupMethod(MDecl->getSelector(), MDecl->isInstanceMethod());
  
  if (IMD) {
    ObjCImplDecl *ImplDeclOfMethodDef = 
      dyn_cast<ObjCImplDecl>(MDecl->getDeclContext());
    ObjCContainerDecl *ContDeclOfMethodDecl = 
      dyn_cast<ObjCContainerDecl>(IMD->getDeclContext());
    ObjCImplDecl *ImplDeclOfMethodDecl = nullptr;
    if (ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(ContDeclOfMethodDecl))
      ImplDeclOfMethodDecl = OID->getImplementation();
    else if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(ContDeclOfMethodDecl)) {
      if (CD->IsClassExtension()) {
        if (ObjCInterfaceDecl *OID = CD->getClassInterface())
          ImplDeclOfMethodDecl = OID->getImplementation();
      } else
          ImplDeclOfMethodDecl = CD->getImplementation();
    }
    // No need to issue deprecated warning if deprecated mehod in class/category
    // is being implemented in its own implementation (no overriding is involved).
    if (!ImplDeclOfMethodDecl || ImplDeclOfMethodDecl != ImplDeclOfMethodDef)
      DiagnoseObjCImplementedDeprecations(*this, IMD, MDecl->getLocation());
  }

  if (MDecl->getMethodFamily() == OMF_init) {
    if (MDecl->isDesignatedInitializerForTheInterface()) {
      getCurFunction()->ObjCIsDesignatedInit = true;
      getCurFunction()->ObjCWarnForNoDesignatedInitChain =
          IC->getSuperClass() != nullptr;
    } else if (IC->hasDesignatedInitializers()) {
      getCurFunction()->ObjCIsSecondaryInit = true;
      getCurFunction()->ObjCWarnForNoInitDelegation = true;
    }
  }

  // If this is "dealloc" or "finalize", set some bit here.
  // Then in ActOnSuperMessage() (SemaExprObjC), set it back to false.
  // Finally, in ActOnFinishFunctionBody() (SemaDecl), warn if flag is set.
  // Only do this if the current class actually has a superclass.
  if (const ObjCInterfaceDecl *SuperClass = IC->getSuperClass()) {
    ObjCMethodFamily Family = MDecl->getMethodFamily();
    if (Family == OMF_dealloc) {
      if (!(getLangOpts().ObjCAutoRefCount ||
            getLangOpts().getGC() == LangOptions::GCOnly))
        getCurFunction()->ObjCShouldCallSuper = true;

    } else if (Family == OMF_finalize) {
      if (Context.getLangOpts().getGC() != LangOptions::NonGC)
        getCurFunction()->ObjCShouldCallSuper = true;
      
    } else {
      const ObjCMethodDecl *SuperMethod =
        SuperClass->lookupMethod(MDecl->getSelector(),
                                 MDecl->isInstanceMethod());
      getCurFunction()->ObjCShouldCallSuper = 
        (SuperMethod && SuperMethod->hasAttr<ObjCRequiresSuperAttr>());
    }
  }
}
494}

496namespace {

498// Callback to only accept typo corrections that are Objective-C classes.
499// If an ObjCInterfaceDecl* is given to the constructor, then the validation
500// function will reject corrections to that class.
501class ObjCInterfaceValidatorCCC : public CorrectionCandidateCallback {
public:
ObjCInterfaceValidatorCCC() : CurrentIDecl(nullptr) {}
explicit ObjCInterfaceValidatorCCC(ObjCInterfaceDecl *IDecl)
    : CurrentIDecl(IDecl) {}

bool ValidateCandidate(const TypoCorrection &candidate) override {
  ObjCInterfaceDecl *ID = candidate.getCorrectionDeclAs<ObjCInterfaceDecl>();
  return ID && !declaresSameEntity(ID, CurrentIDecl);
}

private:
ObjCInterfaceDecl *CurrentIDecl;
514};

516} // end anonymous namespace

518static void diagnoseUseOfProtocols(Sema &TheSema,
                                 ObjCContainerDecl *CD,
                                 ObjCProtocolDecl *const *ProtoRefs,
                                 unsigned NumProtoRefs,
                                 const SourceLocation *ProtoLocs) {
assert(ProtoRefs)(static_cast <bool> (ProtoRefs) ? void (0) : __assert_fail
 ("ProtoRefs", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 523, __extension__ __PRETTY_FUNCTION__));
// Diagnose availability in the context of the ObjC container.
Sema::ContextRAII SavedContext(TheSema, CD);
for (unsigned i = 0; i < NumProtoRefs; ++i) {
  (void)TheSema.DiagnoseUseOfDecl(ProtoRefs[i], ProtoLocs[i],
                                  /*UnknownObjCClass=*/nullptr,
                                  /*ObjCPropertyAccess=*/false,
                                  /*AvoidPartialAvailabilityChecks=*/true);
}
532}

534void Sema::
535ActOnSuperClassOfClassInterface(Scope *S,
                              SourceLocation AtInterfaceLoc,
                              ObjCInterfaceDecl *IDecl,
                              IdentifierInfo *ClassName,
                              SourceLocation ClassLoc,
                              IdentifierInfo *SuperName,
                              SourceLocation SuperLoc,
                              ArrayRef<ParsedType> SuperTypeArgs,
                              SourceRange SuperTypeArgsRange) {
// Check if a different kind of symbol declared in this scope.
NamedDecl *PrevDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
                                       LookupOrdinaryName);

if (!PrevDecl) {
  // Try to correct for a typo in the superclass name without correcting
  // to the class we're defining.
  if (TypoCorrection Corrected = CorrectTypo(
          DeclarationNameInfo(SuperName, SuperLoc),
          LookupOrdinaryName, TUScope,
          nullptr, llvm::make_unique<ObjCInterfaceValidatorCCC>(IDecl),
          CTK_ErrorRecovery)) {
    diagnoseTypo(Corrected, PDiag(diag::err_undef_superclass_suggest)
                 << SuperName << ClassName);
    PrevDecl = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>();
  }
}

if (declaresSameEntity(PrevDecl, IDecl)) {
  Diag(SuperLoc, diag::err_recursive_superclass)
    << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
  IDecl->setEndOfDefinitionLoc(ClassLoc);
} else {
  ObjCInterfaceDecl *SuperClassDecl =
  dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
  QualType SuperClassType;

  // Diagnose classes that inherit from deprecated classes.
  if (SuperClassDecl) {
    (void)DiagnoseUseOfDecl(SuperClassDecl, SuperLoc);
    SuperClassType = Context.getObjCInterfaceType(SuperClassDecl);
  }

  if (PrevDecl && !SuperClassDecl) {
    // The previous declaration was not a class decl. Check if we have a
    // typedef. If we do, get the underlying class type.
    if (const TypedefNameDecl *TDecl =
        dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
      QualType T = TDecl->getUnderlyingType();
      if (T->isObjCObjectType()) {
        if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
          SuperClassDecl = dyn_cast<ObjCInterfaceDecl>(IDecl);
          SuperClassType = Context.getTypeDeclType(TDecl);

          // This handles the following case:
          // @interface NewI @end
          // typedef NewI DeprI __attribute__((deprecated("blah")))
          // @interface SI : DeprI /* warn here */ @end
          (void)DiagnoseUseOfDecl(const_cast<TypedefNameDecl*>(TDecl), SuperLoc);
        }
      }
    }

    // This handles the following case:
    //
    // typedef int SuperClass;
    // @interface MyClass : SuperClass {} @end
    //
    if (!SuperClassDecl) {
      Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;
      Diag(PrevDecl->getLocation(), diag::note_previous_definition);
    }
  }

  if (!dyn_cast_or_null<TypedefNameDecl>(PrevDecl)) {
    if (!SuperClassDecl)
      Diag(SuperLoc, diag::err_undef_superclass)
        << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);
    else if (RequireCompleteType(SuperLoc,
                                 SuperClassType,
                                 diag::err_forward_superclass,
                                 SuperClassDecl->getDeclName(),
                                 ClassName,
                                 SourceRange(AtInterfaceLoc, ClassLoc))) {
      SuperClassDecl = nullptr;
      SuperClassType = QualType();
    }
  }

  if (SuperClassType.isNull()) {
    assert(!SuperClassDecl && "Failed to set SuperClassType?")(static_cast <bool> (!SuperClassDecl && "Failed to set SuperClassType?"
) ? void (0) : __assert_fail ("!SuperClassDecl && \"Failed to set SuperClassType?\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 624, __extension__ __PRETTY_FUNCTION__));
    return;
  }

  // Handle type arguments on the superclass.
  TypeSourceInfo *SuperClassTInfo = nullptr;
  if (!SuperTypeArgs.empty()) {     
    TypeResult fullSuperClassType = actOnObjCTypeArgsAndProtocolQualifiers(
                                      S,
                                      SuperLoc,
                                      CreateParsedType(SuperClassType, 
                                                       nullptr),
                                      SuperTypeArgsRange.getBegin(),
                                      SuperTypeArgs,
                                      SuperTypeArgsRange.getEnd(),
                                      SourceLocation(),
                                      { },
                                      { },
                                      SourceLocation());
    if (!fullSuperClassType.isUsable())
      return;

    SuperClassType = GetTypeFromParser(fullSuperClassType.get(), 
                                       &SuperClassTInfo);
  }

  if (!SuperClassTInfo) {
    SuperClassTInfo = Context.getTrivialTypeSourceInfo(SuperClassType, 
                                                       SuperLoc);
  }

  IDecl->setSuperClass(SuperClassTInfo);
  IDecl->setEndOfDefinitionLoc(SuperClassTInfo->getTypeLoc().getLocEnd());
}
658}

660DeclResult Sema::actOnObjCTypeParam(Scope *S,
                                  ObjCTypeParamVariance variance,
                                  SourceLocation varianceLoc,
                                  unsigned index,
                                  IdentifierInfo *paramName,
                                  SourceLocation paramLoc,
                                  SourceLocation colonLoc,
                                  ParsedType parsedTypeBound) {
// If there was an explicitly-provided type bound, check it.
TypeSourceInfo *typeBoundInfo = nullptr;
if (parsedTypeBound) {
  // The type bound can be any Objective-C pointer type.
  QualType typeBound = GetTypeFromParser(parsedTypeBound, &typeBoundInfo);
  if (typeBound->isObjCObjectPointerType()) {
    // okay
  } else if (typeBound->isObjCObjectType()) {
    // The user forgot the * on an Objective-C pointer type, e.g.,
    // "T : NSView".
    SourceLocation starLoc = getLocForEndOfToken(
                               typeBoundInfo->getTypeLoc().getEndLoc());
    Diag(typeBoundInfo->getTypeLoc().getBeginLoc(),
         diag::err_objc_type_param_bound_missing_pointer)
      << typeBound << paramName
      << FixItHint::CreateInsertion(starLoc, " *");

    // Create a new type location builder so we can update the type
    // location information we have.
    TypeLocBuilder builder;
    builder.pushFullCopy(typeBoundInfo->getTypeLoc());

    // Create the Objective-C pointer type.
    typeBound = Context.getObjCObjectPointerType(typeBound);
    ObjCObjectPointerTypeLoc newT
      = builder.push<ObjCObjectPointerTypeLoc>(typeBound);
    newT.setStarLoc(starLoc);

    // Form the new type source information.
    typeBoundInfo = builder.getTypeSourceInfo(Context, typeBound);
  } else {
    // Not a valid type bound.
    Diag(typeBoundInfo->getTypeLoc().getBeginLoc(),
         diag::err_objc_type_param_bound_nonobject)
      << typeBound << paramName;

    // Forget the bound; we'll default to id later.
    typeBoundInfo = nullptr;
  }

  // Type bounds cannot have qualifiers (even indirectly) or explicit
  // nullability.
  if (typeBoundInfo) {
    QualType typeBound = typeBoundInfo->getType();
    TypeLoc qual = typeBoundInfo->getTypeLoc().findExplicitQualifierLoc();
    if (qual || typeBound.hasQualifiers()) {
      bool diagnosed = false;
      SourceRange rangeToRemove;
      if (qual) {
        if (auto attr = qual.getAs<AttributedTypeLoc>()) {
          rangeToRemove = attr.getLocalSourceRange();
          if (attr.getTypePtr()->getImmediateNullability()) {
            Diag(attr.getLocStart(),
                 diag::err_objc_type_param_bound_explicit_nullability)
              << paramName << typeBound
              << FixItHint::CreateRemoval(rangeToRemove);
            diagnosed = true;
          }
        }
      }

      if (!diagnosed) {
        Diag(qual ? qual.getLocStart()
                  : typeBoundInfo->getTypeLoc().getLocStart(),
            diag::err_objc_type_param_bound_qualified)
          << paramName << typeBound << typeBound.getQualifiers().getAsString()
          << FixItHint::CreateRemoval(rangeToRemove);
      }

      // If the type bound has qualifiers other than CVR, we need to strip
      // them or we'll probably assert later when trying to apply new
      // qualifiers.
      Qualifiers quals = typeBound.getQualifiers();
      quals.removeCVRQualifiers();
      if (!quals.empty()) {
        typeBoundInfo =
           Context.getTrivialTypeSourceInfo(typeBound.getUnqualifiedType());
      }
    }
  }
}

// If there was no explicit type bound (or we removed it due to an error),
// use 'id' instead.
if (!typeBoundInfo) {
  colonLoc = SourceLocation();
  typeBoundInfo = Context.getTrivialTypeSourceInfo(Context.getObjCIdType());
}

// Create the type parameter.
return ObjCTypeParamDecl::Create(Context, CurContext, variance, varianceLoc,
                                 index, paramLoc, paramName, colonLoc,
                                 typeBoundInfo);
761}

763ObjCTypeParamList *Sema::actOnObjCTypeParamList(Scope *S,
                                              SourceLocation lAngleLoc,
                                              ArrayRef<Decl *> typeParamsIn,
                                              SourceLocation rAngleLoc) {
// We know that the array only contains Objective-C type parameters.
ArrayRef<ObjCTypeParamDecl *>
  typeParams(
    reinterpret_cast<ObjCTypeParamDecl * const *>(typeParamsIn.data()),
    typeParamsIn.size());

// Diagnose redeclarations of type parameters.
// We do this now because Objective-C type parameters aren't pushed into
// scope until later (after the instance variable block), but we want the
// diagnostics to occur right after we parse the type parameter list.
llvm::SmallDenseMap<IdentifierInfo *, ObjCTypeParamDecl *> knownParams;
for (auto typeParam : typeParams) {
  auto known = knownParams.find(typeParam->getIdentifier());
  if (known != knownParams.end()) {
    Diag(typeParam->getLocation(), diag::err_objc_type_param_redecl)
      << typeParam->getIdentifier()
      << SourceRange(known->second->getLocation());

    typeParam->setInvalidDecl();
  } else {
    knownParams.insert(std::make_pair(typeParam->getIdentifier(), typeParam));

    // Push the type parameter into scope.
    PushOnScopeChains(typeParam, S, /*AddToContext=*/false);
  }
}

// Create the parameter list.
return ObjCTypeParamList::create(Context, lAngleLoc, typeParams, rAngleLoc);
796}

798void Sema::popObjCTypeParamList(Scope *S, ObjCTypeParamList *typeParamList) {
for (auto typeParam : *typeParamList) {
  if (!typeParam->isInvalidDecl()) {
    S->RemoveDecl(typeParam);
    IdResolver.RemoveDecl(typeParam);
  }
}
805}

807namespace {
/// The context in which an Objective-C type parameter list occurs, for use
/// in diagnostics.
enum class TypeParamListContext {
  ForwardDeclaration,
  Definition,
  Category,
  Extension
};
816} // end anonymous namespace

818/// Check consistency between two Objective-C type parameter lists, e.g.,
819/// between a category/extension and an \@interface or between an \@class and an
820/// \@interface.
821static bool checkTypeParamListConsistency(Sema &S,
                                        ObjCTypeParamList *prevTypeParams,
                                        ObjCTypeParamList *newTypeParams,
                                        TypeParamListContext newContext) {
// If the sizes don't match, complain about that.
if (prevTypeParams->size() != newTypeParams->size()) {
  SourceLocation diagLoc;
  if (newTypeParams->size() > prevTypeParams->size()) {
    diagLoc = newTypeParams->begin()[prevTypeParams->size()]->getLocation();
  } else {
    diagLoc = S.getLocForEndOfToken(newTypeParams->back()->getLocEnd());
  }

  S.Diag(diagLoc, diag::err_objc_type_param_arity_mismatch)
    << static_cast<unsigned>(newContext)
    << (newTypeParams->size() > prevTypeParams->size())
    << prevTypeParams->size()
    << newTypeParams->size();

  return true;
}

// Match up the type parameters.
for (unsigned i = 0, n = prevTypeParams->size(); i != n; ++i) {
  ObjCTypeParamDecl *prevTypeParam = prevTypeParams->begin()[i];
  ObjCTypeParamDecl *newTypeParam = newTypeParams->begin()[i];

  // Check for consistency of the variance.
  if (newTypeParam->getVariance() != prevTypeParam->getVariance()) {
    if (newTypeParam->getVariance() == ObjCTypeParamVariance::Invariant &&
        newContext != TypeParamListContext::Definition) {
      // When the new type parameter is invariant and is not part
      // of the definition, just propagate the variance.
      newTypeParam->setVariance(prevTypeParam->getVariance());
    } else if (prevTypeParam->getVariance() 
                 == ObjCTypeParamVariance::Invariant &&
               !(isa<ObjCInterfaceDecl>(prevTypeParam->getDeclContext()) &&
                 cast<ObjCInterfaceDecl>(prevTypeParam->getDeclContext())
                   ->getDefinition() == prevTypeParam->getDeclContext())) {
      // When the old parameter is invariant and was not part of the
      // definition, just ignore the difference because it doesn't
      // matter.
    } else {
      {
        // Diagnose the conflict and update the second declaration.
        SourceLocation diagLoc = newTypeParam->getVarianceLoc();
        if (diagLoc.isInvalid())
          diagLoc = newTypeParam->getLocStart();

        auto diag = S.Diag(diagLoc,
                           diag::err_objc_type_param_variance_conflict)
                      << static_cast<unsigned>(newTypeParam->getVariance())
                      << newTypeParam->getDeclName()
                      << static_cast<unsigned>(prevTypeParam->getVariance())
                      << prevTypeParam->getDeclName();
        switch (prevTypeParam->getVariance()) {
        case ObjCTypeParamVariance::Invariant:
          diag << FixItHint::CreateRemoval(newTypeParam->getVarianceLoc());
          break;

        case ObjCTypeParamVariance::Covariant:
        case ObjCTypeParamVariance::Contravariant: {
          StringRef newVarianceStr
             = prevTypeParam->getVariance() == ObjCTypeParamVariance::Covariant
                 ? "__covariant"
                 : "__contravariant";
          if (newTypeParam->getVariance()
                == ObjCTypeParamVariance::Invariant) {
            diag << FixItHint::CreateInsertion(newTypeParam->getLocStart(),
                                               (newVarianceStr + " ").str());
          } else {
            diag << FixItHint::CreateReplacement(newTypeParam->getVarianceLoc(),
                                             newVarianceStr);
          }
        }
        }
      }

      S.Diag(prevTypeParam->getLocation(), diag::note_objc_type_param_here)
        << prevTypeParam->getDeclName();

      // Override the variance.
      newTypeParam->setVariance(prevTypeParam->getVariance());
    }
  }

  // If the bound types match, there's nothing to do.
  if (S.Context.hasSameType(prevTypeParam->getUnderlyingType(),
                            newTypeParam->getUnderlyingType()))
    continue;

  // If the new type parameter's bound was explicit, complain about it being
  // different from the original.
  if (newTypeParam->hasExplicitBound()) {
    SourceRange newBoundRange = newTypeParam->getTypeSourceInfo()
                                  ->getTypeLoc().getSourceRange();
    S.Diag(newBoundRange.getBegin(), diag::err_objc_type_param_bound_conflict)
      << newTypeParam->getUnderlyingType()
      << newTypeParam->getDeclName()
      << prevTypeParam->hasExplicitBound()
      << prevTypeParam->getUnderlyingType()
      << (newTypeParam->getDeclName() == prevTypeParam->getDeclName())
      << prevTypeParam->getDeclName()
      << FixItHint::CreateReplacement(
           newBoundRange,
           prevTypeParam->getUnderlyingType().getAsString(
             S.Context.getPrintingPolicy()));

    S.Diag(prevTypeParam->getLocation(), diag::note_objc_type_param_here)
      << prevTypeParam->getDeclName();

    // Override the new type parameter's bound type with the previous type,
    // so that it's consistent.
    newTypeParam->setTypeSourceInfo(
      S.Context.getTrivialTypeSourceInfo(prevTypeParam->getUnderlyingType()));
    continue;
  }

  // The new type parameter got the implicit bound of 'id'. That's okay for
  // categories and extensions (overwrite it later), but not for forward
  // declarations and @interfaces, because those must be standalone.
  if (newContext == TypeParamListContext::ForwardDeclaration ||
      newContext == TypeParamListContext::Definition) {
    // Diagnose this problem for forward declarations and definitions.
    SourceLocation insertionLoc
      = S.getLocForEndOfToken(newTypeParam->getLocation());
    std::string newCode
      = " : " + prevTypeParam->getUnderlyingType().getAsString(
                  S.Context.getPrintingPolicy());
    S.Diag(newTypeParam->getLocation(),
           diag::err_objc_type_param_bound_missing)
      << prevTypeParam->getUnderlyingType()
      << newTypeParam->getDeclName()
      << (newContext == TypeParamListContext::ForwardDeclaration)
      << FixItHint::CreateInsertion(insertionLoc, newCode);

    S.Diag(prevTypeParam->getLocation(), diag::note_objc_type_param_here)
      << prevTypeParam->getDeclName();
  }

  // Update the new type parameter's bound to match the previous one.
  newTypeParam->setTypeSourceInfo(
    S.Context.getTrivialTypeSourceInfo(prevTypeParam->getUnderlyingType()));
}

return false;
967}

969Decl *Sema::ActOnStartClassInterface(
  Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
  SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
  IdentifierInfo *SuperName, SourceLocation SuperLoc,
  ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange,
  Decl *const *ProtoRefs, unsigned NumProtoRefs,
  const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
  const ParsedAttributesView &AttrList) {
assert(ClassName && "Missing class identifier")(static_cast <bool> (ClassName && "Missing class identifier"
) ? void (0) : __assert_fail ("ClassName && \"Missing class identifier\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 977, __extension__ __PRETTY_FUNCTION__));

// Check for another declaration kind with the same name.
NamedDecl *PrevDecl =
    LookupSingleName(TUScope, ClassName, ClassLoc, LookupOrdinaryName,
                     forRedeclarationInCurContext());

if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
  Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
}

// Create a declaration to describe this @interface.
ObjCInterfaceDecl* PrevIDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);

if (PrevIDecl && PrevIDecl->getIdentifier() != ClassName) {
  // A previous decl with a different name is because of
  // @compatibility_alias, for example:
  // \code
  //   @class NewImage;
  //   @compatibility_alias OldImage NewImage;
  // \endcode
  // A lookup for 'OldImage' will return the 'NewImage' decl.
  //
  // In such a case use the real declaration name, instead of the alias one,
  // otherwise we will break IdentifierResolver and redecls-chain invariants.
  // FIXME: If necessary, add a bit to indicate that this ObjCInterfaceDecl
  // has been aliased.
  ClassName = PrevIDecl->getIdentifier();
}

// If there was a forward declaration with type parameters, check
// for consistency.
if (PrevIDecl) {
  if (ObjCTypeParamList *prevTypeParamList = PrevIDecl->getTypeParamList()) {
    if (typeParamList) {
      // Both have type parameter lists; check for consistency.
      if (checkTypeParamListConsistency(*this, prevTypeParamList, 
                                        typeParamList,
                                        TypeParamListContext::Definition)) {
        typeParamList = nullptr;
      }
    } else {
      Diag(ClassLoc, diag::err_objc_parameterized_forward_class_first)
        << ClassName;
      Diag(prevTypeParamList->getLAngleLoc(), diag::note_previous_decl)
        << ClassName;

      // Clone the type parameter list.
      SmallVector<ObjCTypeParamDecl *, 4> clonedTypeParams;
      for (auto typeParam : *prevTypeParamList) {
        clonedTypeParams.push_back(
          ObjCTypeParamDecl::Create(
            Context,
            CurContext,
            typeParam->getVariance(),
            SourceLocation(),
            typeParam->getIndex(),
            SourceLocation(),
            typeParam->getIdentifier(),
            SourceLocation(),
            Context.getTrivialTypeSourceInfo(typeParam->getUnderlyingType())));
      }

      typeParamList = ObjCTypeParamList::create(Context, 
                                                SourceLocation(),
                                                clonedTypeParams,
                                                SourceLocation());
    }
  }
}

ObjCInterfaceDecl *IDecl
  = ObjCInterfaceDecl::Create(Context, CurContext, AtInterfaceLoc, ClassName,
                              typeParamList, PrevIDecl, ClassLoc);
if (PrevIDecl) {
  // Class already seen. Was it a definition?
  if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
    Diag(AtInterfaceLoc, diag::err_duplicate_class_def)
      << PrevIDecl->getDeclName();
    Diag(Def->getLocation(), diag::note_previous_definition);
    IDecl->setInvalidDecl();
  }
}

ProcessDeclAttributeList(TUScope, IDecl, AttrList);
AddPragmaAttributes(TUScope, IDecl);
PushOnScopeChains(IDecl, TUScope);

// Start the definition of this class. If we're in a redefinition case, there 
// may already be a definition, so we'll end up adding to it.
if (!IDecl->hasDefinition())
  IDecl->startDefinition();

if (SuperName) {
  // Diagnose availability in the context of the @interface.
  ContextRAII SavedContext(*this, IDecl);

  ActOnSuperClassOfClassInterface(S, AtInterfaceLoc, IDecl, 
                                  ClassName, ClassLoc, 
                                  SuperName, SuperLoc, SuperTypeArgs, 
                                  SuperTypeArgsRange);
} else { // we have a root class.
  IDecl->setEndOfDefinitionLoc(ClassLoc);
}

// Check then save referenced protocols.
if (NumProtoRefs) {
  diagnoseUseOfProtocols(*this, IDecl, (ObjCProtocolDecl*const*)ProtoRefs,
                         NumProtoRefs, ProtoLocs);
  IDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
                         ProtoLocs, Context);
  IDecl->setEndOfDefinitionLoc(EndProtoLoc);
}

CheckObjCDeclScope(IDecl);
return ActOnObjCContainerStartDefinition(IDecl);
1094}

1096/// ActOnTypedefedProtocols - this action finds protocol list as part of the
1097/// typedef'ed use for a qualified super class and adds them to the list
1098/// of the protocols.
1099void Sema::ActOnTypedefedProtocols(SmallVectorImpl<Decl *> &ProtocolRefs,
                                SmallVectorImpl<SourceLocation> &ProtocolLocs,
                                 IdentifierInfo *SuperName,
                                 SourceLocation SuperLoc) {
if (!SuperName)
  return;
NamedDecl* IDecl = LookupSingleName(TUScope, SuperName, SuperLoc,
                                    LookupOrdinaryName);
if (!IDecl)
  return;

if (const TypedefNameDecl *TDecl = dyn_cast_or_null<TypedefNameDecl>(IDecl)) {
  QualType T = TDecl->getUnderlyingType();
  if (T->isObjCObjectType())
    if (const ObjCObjectType *OPT = T->getAs<ObjCObjectType>()) {
      ProtocolRefs.append(OPT->qual_begin(), OPT->qual_end());
      // FIXME: Consider whether this should be an invalid loc since the loc
      // is not actually pointing to a protocol name reference but to the
      // typedef reference. Note that the base class name loc is also pointing
      // at the typedef.
      ProtocolLocs.append(OPT->getNumProtocols(), SuperLoc);
    }
}
1122}

1124/// ActOnCompatibilityAlias - this action is called after complete parsing of
1125/// a \@compatibility_alias declaration. It sets up the alias relationships.
1126Decl *Sema::ActOnCompatibilityAlias(SourceLocation AtLoc,
                                  IdentifierInfo *AliasName,
                                  SourceLocation AliasLocation,
                                  IdentifierInfo *ClassName,
                                  SourceLocation ClassLocation) {
// Look for previous declaration of alias name
NamedDecl *ADecl =
    LookupSingleName(TUScope, AliasName, AliasLocation, LookupOrdinaryName,
                     forRedeclarationInCurContext());
if (ADecl) {
  Diag(AliasLocation, diag::err_conflicting_aliasing_type) << AliasName;
  Diag(ADecl->getLocation(), diag::note_previous_declaration);
  return nullptr;
}
// Check for class declaration
NamedDecl *CDeclU =
    LookupSingleName(TUScope, ClassName, ClassLocation, LookupOrdinaryName,
                     forRedeclarationInCurContext());
if (const TypedefNameDecl *TDecl =
      dyn_cast_or_null<TypedefNameDecl>(CDeclU)) {
  QualType T = TDecl->getUnderlyingType();
  if (T->isObjCObjectType()) {
    if (NamedDecl *IDecl = T->getAs<ObjCObjectType>()->getInterface()) {
      ClassName = IDecl->getIdentifier();
      CDeclU = LookupSingleName(TUScope, ClassName, ClassLocation,
                                LookupOrdinaryName,
                                forRedeclarationInCurContext());
    }
  }
}
ObjCInterfaceDecl *CDecl = dyn_cast_or_null<ObjCInterfaceDecl>(CDeclU);
if (!CDecl) {
  Diag(ClassLocation, diag::warn_undef_interface) << ClassName;
  if (CDeclU)
    Diag(CDeclU->getLocation(), diag::note_previous_declaration);
  return nullptr;
}

// Everything checked out, instantiate a new alias declaration AST.
ObjCCompatibleAliasDecl *AliasDecl =
  ObjCCompatibleAliasDecl::Create(Context, CurContext, AtLoc, AliasName, CDecl);

if (!CheckObjCDeclScope(AliasDecl))
  PushOnScopeChains(AliasDecl, TUScope);

return AliasDecl;
1172}

1174bool Sema::CheckForwardProtocolDeclarationForCircularDependency(
IdentifierInfo *PName,
SourceLocation &Ploc, SourceLocation PrevLoc,
const ObjCList<ObjCProtocolDecl> &PList) {

bool res = false;
for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(),
     E = PList.end(); I != E; ++I) {
  if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier(),
                                               Ploc)) {
    if (PDecl->getIdentifier() == PName) {
      Diag(Ploc, diag::err_protocol_has_circular_dependency);
      Diag(PrevLoc, diag::note_previous_definition);
      res = true;
    }
    
    if (!PDecl->hasDefinition())
      continue;
    
    if (CheckForwardProtocolDeclarationForCircularDependency(PName, Ploc,
          PDecl->getLocation(), PDecl->getReferencedProtocols()))
      res = true;
  }
}
return res;
1199}

1201Decl *Sema::ActOnStartProtocolInterface(
  SourceLocation AtProtoInterfaceLoc, IdentifierInfo *ProtocolName,
  SourceLocation ProtocolLoc, Decl *const *ProtoRefs, unsigned NumProtoRefs,
  const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
  const ParsedAttributesView &AttrList) {
bool err = false;
// FIXME: Deal with AttrList.
assert(ProtocolName && "Missing protocol identifier")(static_cast <bool> (ProtocolName && "Missing protocol identifier"
) ? void (0) : __assert_fail ("ProtocolName && \"Missing protocol identifier\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1208, __extension__ __PRETTY_FUNCTION__));
ObjCProtocolDecl *PrevDecl = LookupProtocol(ProtocolName, ProtocolLoc,
                                            forRedeclarationInCurContext());
ObjCProtocolDecl *PDecl = nullptr;
if (ObjCProtocolDecl *Def = PrevDecl? PrevDecl->getDefinition() : nullptr) {
  // If we already have a definition, complain.
  Diag(ProtocolLoc, diag::warn_duplicate_protocol_def) << ProtocolName;
  Diag(Def->getLocation(), diag::note_previous_definition);

  // Create a new protocol that is completely distinct from previous
  // declarations, and do not make this protocol available for name lookup.
  // That way, we'll end up completely ignoring the duplicate.
  // FIXME: Can we turn this into an error?
  PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
                                   ProtocolLoc, AtProtoInterfaceLoc,
                                   /*PrevDecl=*/nullptr);

  // If we are using modules, add the decl to the context in order to
  // serialize something meaningful.
  if (getLangOpts().Modules)
    PushOnScopeChains(PDecl, TUScope);
  PDecl->startDefinition();
} else {
  if (PrevDecl) {
    // Check for circular dependencies among protocol declarations. This can
    // only happen if this protocol was forward-declared.
    ObjCList<ObjCProtocolDecl> PList;
    PList.set((ObjCProtocolDecl *const*)ProtoRefs, NumProtoRefs, Context);
    err = CheckForwardProtocolDeclarationForCircularDependency(
            ProtocolName, ProtocolLoc, PrevDecl->getLocation(), PList);
  }

  // Create the new declaration.
  PDecl = ObjCProtocolDecl::Create(Context, CurContext, ProtocolName,
                                   ProtocolLoc, AtProtoInterfaceLoc,
                                   /*PrevDecl=*/PrevDecl);
  
  PushOnScopeChains(PDecl, TUScope);
  PDecl->startDefinition();
}

ProcessDeclAttributeList(TUScope, PDecl, AttrList);
AddPragmaAttributes(TUScope, PDecl);

// Merge attributes from previous declarations.
if (PrevDecl)
  mergeDeclAttributes(PDecl, PrevDecl);

if (!err && NumProtoRefs ) {
  /// Check then save referenced protocols.
  diagnoseUseOfProtocols(*this, PDecl, (ObjCProtocolDecl*const*)ProtoRefs,
                         NumProtoRefs, ProtoLocs);
  PDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
                         ProtoLocs, Context);
}

CheckObjCDeclScope(PDecl);
return ActOnObjCContainerStartDefinition(PDecl);
1266}

1268static bool NestedProtocolHasNoDefinition(ObjCProtocolDecl *PDecl,
                                        ObjCProtocolDecl *&UndefinedProtocol) {
if (!PDecl->hasDefinition() || PDecl->getDefinition()->isHidden()) {
  UndefinedProtocol = PDecl;
  return true;
}

for (auto *PI : PDecl->protocols())
  if (NestedProtocolHasNoDefinition(PI, UndefinedProtocol)) {
    UndefinedProtocol = PI;
    return true;
  }
return false;
1281}

1283/// FindProtocolDeclaration - This routine looks up protocols and
1284/// issues an error if they are not declared. It returns list of
1285/// protocol declarations in its 'Protocols' argument.
1286void
1287Sema::FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer,
                            ArrayRef<IdentifierLocPair> ProtocolId,
                            SmallVectorImpl<Decl *> &Protocols) {
for (const IdentifierLocPair &Pair : ProtocolId) {
  ObjCProtocolDecl *PDecl = LookupProtocol(Pair.first, Pair.second);
  if (!PDecl) {
    TypoCorrection Corrected = CorrectTypo(
        DeclarationNameInfo(Pair.first, Pair.second),
        LookupObjCProtocolName, TUScope, nullptr,
        llvm::make_unique<DeclFilterCCC<ObjCProtocolDecl>>(),
        CTK_ErrorRecovery);
    if ((PDecl = Corrected.getCorrectionDeclAs<ObjCProtocolDecl>()))
      diagnoseTypo(Corrected, PDiag(diag::err_undeclared_protocol_suggest)
                                  << Pair.first);
  }

  if (!PDecl) {
    Diag(Pair.second, diag::err_undeclared_protocol) << Pair.first;
    continue;
  }
  // If this is a forward protocol declaration, get its definition.
  if (!PDecl->isThisDeclarationADefinition() && PDecl->getDefinition())
    PDecl = PDecl->getDefinition();

  // For an objc container, delay protocol reference checking until after we
  // can set the objc decl as the availability context, otherwise check now.
  if (!ForObjCContainer) {
    (void)DiagnoseUseOfDecl(PDecl, Pair.second);
  }

  // If this is a forward declaration and we are supposed to warn in this
  // case, do it.
  // FIXME: Recover nicely in the hidden case.
  ObjCProtocolDecl *UndefinedProtocol;
  
  if (WarnOnDeclarations &&
      NestedProtocolHasNoDefinition(PDecl, UndefinedProtocol)) {
    Diag(Pair.second, diag::warn_undef_protocolref) << Pair.first;
    Diag(UndefinedProtocol->getLocation(), diag::note_protocol_decl_undefined)
      << UndefinedProtocol;
  }
  Protocols.push_back(PDecl);
}
1330}

1332namespace {
1333// Callback to only accept typo corrections that are either
1334// Objective-C protocols or valid Objective-C type arguments.
1335class ObjCTypeArgOrProtocolValidatorCCC : public CorrectionCandidateCallback {
ASTContext &Context;
Sema::LookupNameKind LookupKind;
public:
ObjCTypeArgOrProtocolValidatorCCC(ASTContext &context,
                                  Sema::LookupNameKind lookupKind)
  : Context(context), LookupKind(lookupKind) { }

bool ValidateCandidate(const TypoCorrection &candidate) override {
  // If we're allowed to find protocols and we have a protocol, accept it.
  if (LookupKind != Sema::LookupOrdinaryName) {
    if (candidate.getCorrectionDeclAs<ObjCProtocolDecl>())
      return true;
  }

  // If we're allowed to find type names and we have one, accept it.
  if (LookupKind != Sema::LookupObjCProtocolName) {
    // If we have a type declaration, we might accept this result.
    if (auto typeDecl = candidate.getCorrectionDeclAs<TypeDecl>()) {
      // If we found a tag declaration outside of C++, skip it. This
      // can happy because we look for any name when there is no
      // bias to protocol or type names.
      if (isa<RecordDecl>(typeDecl) && !Context.getLangOpts().CPlusPlus)
        return false;

      // Make sure the type is something we would accept as a type
      // argument.
      auto type = Context.getTypeDeclType(typeDecl);
      if (type->isObjCObjectPointerType() ||
          type->isBlockPointerType() ||
          type->isDependentType() ||
          type->isObjCObjectType())
        return true;

      return false;
    }

    // If we have an Objective-C class type, accept it; there will
    // be another fix to add the '*'.
    if (candidate.getCorrectionDeclAs<ObjCInterfaceDecl>())
      return true;

    return false;
  }

  return false;
}
1382};
1383} // end anonymous namespace

1385void Sema::DiagnoseTypeArgsAndProtocols(IdentifierInfo *ProtocolId,
                                      SourceLocation ProtocolLoc,
                                      IdentifierInfo *TypeArgId,
                                      SourceLocation TypeArgLoc,
                                      bool SelectProtocolFirst) {
Diag(TypeArgLoc, diag::err_objc_type_args_and_protocols)
    << SelectProtocolFirst << TypeArgId << ProtocolId
    << SourceRange(ProtocolLoc);
1393}

1395void Sema::actOnObjCTypeArgsOrProtocolQualifiers(
     Scope *S,
     ParsedType baseType,
     SourceLocation lAngleLoc,
     ArrayRef<IdentifierInfo *> identifiers,
     ArrayRef<SourceLocation> identifierLocs,
     SourceLocation rAngleLoc,
     SourceLocation &typeArgsLAngleLoc,
     SmallVectorImpl<ParsedType> &typeArgs,
     SourceLocation &typeArgsRAngleLoc,
     SourceLocation &protocolLAngleLoc,
     SmallVectorImpl<Decl *> &protocols,
     SourceLocation &protocolRAngleLoc,
     bool warnOnIncompleteProtocols) {
// Local function that updates the declaration specifiers with
// protocol information.
unsigned numProtocolsResolved = 0;
auto resolvedAsProtocols = [&] {
  assert(numProtocolsResolved == identifiers.size() && "Unresolved protocols")(static_cast <bool> (numProtocolsResolved == identifiers
.size() && "Unresolved protocols") ? void (0) : __assert_fail
 ("numProtocolsResolved == identifiers.size() && \"Unresolved protocols\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1413, __extension__ __PRETTY_FUNCTION__));
  
  // Determine whether the base type is a parameterized class, in
  // which case we want to warn about typos such as
  // "NSArray<NSObject>" (that should be NSArray<NSObject *>).
  ObjCInterfaceDecl *baseClass = nullptr;
  QualType base = GetTypeFromParser(baseType, nullptr);
  bool allAreTypeNames = false;
  SourceLocation firstClassNameLoc;
  if (!base.isNull()) {
    if (const auto *objcObjectType = base->getAs<ObjCObjectType>()) {
      baseClass = objcObjectType->getInterface();
      if (baseClass) {
        if (auto typeParams = baseClass->getTypeParamList()) {
          if (typeParams->size() == numProtocolsResolved) {
            // Note that we should be looking for type names, too.
            allAreTypeNames = true;
          }
        }
      }
    }
  }

  for (unsigned i = 0, n = protocols.size(); i != n; ++i) {
    ObjCProtocolDecl *&proto 
      = reinterpret_cast<ObjCProtocolDecl *&>(protocols[i]);
    // For an objc container, delay protocol reference checking until after we
    // can set the objc decl as the availability context, otherwise check now.
    if (!warnOnIncompleteProtocols) {
      (void)DiagnoseUseOfDecl(proto, identifierLocs[i]);
    }

    // If this is a forward protocol declaration, get its definition.
    if (!proto->isThisDeclarationADefinition() && proto->getDefinition())
      proto = proto->getDefinition();

    // If this is a forward declaration and we are supposed to warn in this
    // case, do it.
    // FIXME: Recover nicely in the hidden case.
    ObjCProtocolDecl *forwardDecl = nullptr;
    if (warnOnIncompleteProtocols &&
        NestedProtocolHasNoDefinition(proto, forwardDecl)) {
      Diag(identifierLocs[i], diag::warn_undef_protocolref)
        << proto->getDeclName();
      Diag(forwardDecl->getLocation(), diag::note_protocol_decl_undefined)
        << forwardDecl;
    }

    // If everything this far has been a type name (and we care
    // about such things), check whether this name refers to a type
    // as well.
    if (allAreTypeNames) {
      if (auto *decl = LookupSingleName(S, identifiers[i], identifierLocs[i],
                                        LookupOrdinaryName)) {
        if (isa<ObjCInterfaceDecl>(decl)) {
          if (firstClassNameLoc.isInvalid())
            firstClassNameLoc = identifierLocs[i];
        } else if (!isa<TypeDecl>(decl)) {
          // Not a type.
          allAreTypeNames = false;
        }
      } else {
        allAreTypeNames = false;
      }
    }
  }
  
  // All of the protocols listed also have type names, and at least
  // one is an Objective-C class name. Check whether all of the
  // protocol conformances are declared by the base class itself, in
  // which case we warn.
  if (allAreTypeNames && firstClassNameLoc.isValid()) {
    llvm::SmallPtrSet<ObjCProtocolDecl*, 8> knownProtocols;
    Context.CollectInheritedProtocols(baseClass, knownProtocols);
    bool allProtocolsDeclared = true;
    for (auto proto : protocols) {
      if (knownProtocols.count(static_cast<ObjCProtocolDecl *>(proto)) == 0) {
        allProtocolsDeclared = false;
        break;
      }
    }

    if (allProtocolsDeclared) {
      Diag(firstClassNameLoc, diag::warn_objc_redundant_qualified_class_type)
        << baseClass->getDeclName() << SourceRange(lAngleLoc, rAngleLoc)
        << FixItHint::CreateInsertion(getLocForEndOfToken(firstClassNameLoc),
                                      " *");
    }
  }

  protocolLAngleLoc = lAngleLoc;
  protocolRAngleLoc = rAngleLoc;
  assert(protocols.size() == identifierLocs.size())(static_cast <bool> (protocols.size() == identifierLocs
.size()) ? void (0) : __assert_fail ("protocols.size() == identifierLocs.size()"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1505, __extension__ __PRETTY_FUNCTION__));
};

// Attempt to resolve all of the identifiers as protocols.
for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
  ObjCProtocolDecl *proto = LookupProtocol(identifiers[i], identifierLocs[i]);
  protocols.push_back(proto);
  if (proto)
    ++numProtocolsResolved;
}

// If all of the names were protocols, these were protocol qualifiers.
if (numProtocolsResolved == identifiers.size())
  return resolvedAsProtocols();

// Attempt to resolve all of the identifiers as type names or
// Objective-C class names. The latter is technically ill-formed,
// but is probably something like \c NSArray<NSView *> missing the
// \c*.
typedef llvm::PointerUnion<TypeDecl *, ObjCInterfaceDecl *> TypeOrClassDecl;
SmallVector<TypeOrClassDecl, 4> typeDecls;
unsigned numTypeDeclsResolved = 0;
for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
  NamedDecl *decl = LookupSingleName(S, identifiers[i], identifierLocs[i],
                                     LookupOrdinaryName);
  if (!decl) {
    typeDecls.push_back(TypeOrClassDecl());
    continue;
  }

  if (auto typeDecl = dyn_cast<TypeDecl>(decl)) {
    typeDecls.push_back(typeDecl);
    ++numTypeDeclsResolved;
    continue;
  }

  if (auto objcClass = dyn_cast<ObjCInterfaceDecl>(decl)) {
    typeDecls.push_back(objcClass);
    ++numTypeDeclsResolved;
    continue;
  }

  typeDecls.push_back(TypeOrClassDecl());
}

AttributeFactory attrFactory;

// Local function that forms a reference to the given type or
// Objective-C class declaration.
auto resolveTypeReference = [&](TypeOrClassDecl typeDecl, SourceLocation loc) 
                              -> TypeResult {
  // Form declaration specifiers. They simply refer to the type.
  DeclSpec DS(attrFactory);
  const char* prevSpec; // unused
  unsigned diagID; // unused
  QualType type;
  if (auto *actualTypeDecl = typeDecl.dyn_cast<TypeDecl *>())
    type = Context.getTypeDeclType(actualTypeDecl);
  else
    type = Context.getObjCInterfaceType(typeDecl.get<ObjCInterfaceDecl *>());
  TypeSourceInfo *parsedTSInfo = Context.getTrivialTypeSourceInfo(type, loc);
  ParsedType parsedType = CreateParsedType(type, parsedTSInfo);
  DS.SetTypeSpecType(DeclSpec::TST_typename, loc, prevSpec, diagID,
                     parsedType, Context.getPrintingPolicy());
  // Use the identifier location for the type source range.
  DS.SetRangeStart(loc);
  DS.SetRangeEnd(loc);

  // Form the declarator.
  Declarator D(DS, DeclaratorContext::TypeNameContext);

  // If we have a typedef of an Objective-C class type that is missing a '*',
  // add the '*'.
  if (type->getAs<ObjCInterfaceType>()) {
    SourceLocation starLoc = getLocForEndOfToken(loc);
    D.AddTypeInfo(DeclaratorChunk::getPointer(/*typeQuals=*/0, starLoc,
                                              SourceLocation(),
                                              SourceLocation(),
                                              SourceLocation(),
                                              SourceLocation(),
                                              SourceLocation()),
                                              starLoc);

    // Diagnose the missing '*'.
    Diag(loc, diag::err_objc_type_arg_missing_star)
      << type
      << FixItHint::CreateInsertion(starLoc, " *");
  }

  // Convert this to a type.
  return ActOnTypeName(S, D);
};

// Local function that updates the declaration specifiers with
// type argument information.
auto resolvedAsTypeDecls = [&] {
  // We did not resolve these as protocols.
  protocols.clear();

  assert(numTypeDeclsResolved == identifiers.size() && "Unresolved type decl")(static_cast <bool> (numTypeDeclsResolved == identifiers
.size() && "Unresolved type decl") ? void (0) : __assert_fail
 ("numTypeDeclsResolved == identifiers.size() && \"Unresolved type decl\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1604, __extension__ __PRETTY_FUNCTION__));
  // Map type declarations to type arguments.
  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
    // Map type reference to a type.
    TypeResult type = resolveTypeReference(typeDecls[i], identifierLocs[i]);
    if (!type.isUsable()) {
      typeArgs.clear();
      return;
    }

    typeArgs.push_back(type.get());
  }

  typeArgsLAngleLoc = lAngleLoc;
  typeArgsRAngleLoc = rAngleLoc;
};

// If all of the identifiers can be resolved as type names or
// Objective-C class names, we have type arguments.
if (numTypeDeclsResolved == identifiers.size())
  return resolvedAsTypeDecls();

// Error recovery: some names weren't found, or we have a mix of
// type and protocol names. Go resolve all of the unresolved names
// and complain if we can't find a consistent answer.
LookupNameKind lookupKind = LookupAnyName;
for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {
  // If we already have a protocol or type. Check whether it is the
  // right thing.
  if (protocols[i] || typeDecls[i]) {
    // If we haven't figured out whether we want types or protocols
    // yet, try to figure it out from this name.
    if (lookupKind == LookupAnyName) {
      // If this name refers to both a protocol and a type (e.g., \c
      // NSObject), don't conclude anything yet.
      if (protocols[i] && typeDecls[i])
        continue;

      // Otherwise, let this name decide whether we'll be correcting
      // toward types or protocols.
      lookupKind = protocols[i] ? LookupObjCProtocolName
                                : LookupOrdinaryName;
      continue;
    }

    // If we want protocols and we have a protocol, there's nothing
    // more to do.
    if (lookupKind == LookupObjCProtocolName && protocols[i])
      continue;

    // If we want types and we have a type declaration, there's
    // nothing more to do.
    if (lookupKind == LookupOrdinaryName && typeDecls[i])
      continue;

    // We have a conflict: some names refer to protocols and others
    // refer to types.
    DiagnoseTypeArgsAndProtocols(identifiers[0], identifierLocs[0],
                                 identifiers[i], identifierLocs[i],
                                 protocols[i] != nullptr);

    protocols.clear();
    typeArgs.clear();
    return;
  }

  // Perform typo correction on the name.
  TypoCorrection corrected = CorrectTypo(
      DeclarationNameInfo(identifiers[i], identifierLocs[i]), lookupKind, S,
      nullptr,
      llvm::make_unique<ObjCTypeArgOrProtocolValidatorCCC>(Context,
                                                           lookupKind),
      CTK_ErrorRecovery);
  if (corrected) {
    // Did we find a protocol?
    if (auto proto = corrected.getCorrectionDeclAs<ObjCProtocolDecl>()) {
      diagnoseTypo(corrected,
                   PDiag(diag::err_undeclared_protocol_suggest)
                     << identifiers[i]);
      lookupKind = LookupObjCProtocolName;
      protocols[i] = proto;
      ++numProtocolsResolved;
      continue;
    }

    // Did we find a type?
    if (auto typeDecl = corrected.getCorrectionDeclAs<TypeDecl>()) {
      diagnoseTypo(corrected,
                   PDiag(diag::err_unknown_typename_suggest)
                     << identifiers[i]);
      lookupKind = LookupOrdinaryName;
      typeDecls[i] = typeDecl;
      ++numTypeDeclsResolved;
      continue;
    }

    // Did we find an Objective-C class?
    if (auto objcClass = corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
      diagnoseTypo(corrected,
                   PDiag(diag::err_unknown_type_or_class_name_suggest)
                     << identifiers[i] << true);
      lookupKind = LookupOrdinaryName;
      typeDecls[i] = objcClass;
      ++numTypeDeclsResolved;
      continue;
    }
  }

  // We couldn't find anything.
  Diag(identifierLocs[i],
       (lookupKind == LookupAnyName ? diag::err_objc_type_arg_missing
        : lookupKind == LookupObjCProtocolName ? diag::err_undeclared_protocol
        : diag::err_unknown_typename))
    << identifiers[i];
  protocols.clear();
  typeArgs.clear();
  return;
}

// If all of the names were (corrected to) protocols, these were
// protocol qualifiers.
if (numProtocolsResolved == identifiers.size())
  return resolvedAsProtocols();

// Otherwise, all of the names were (corrected to) types.
assert(numTypeDeclsResolved == identifiers.size() && "Not all types?")(static_cast <bool> (numTypeDeclsResolved == identifiers
.size() && "Not all types?") ? void (0) : __assert_fail
 ("numTypeDeclsResolved == identifiers.size() && \"Not all types?\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1729, __extension__ __PRETTY_FUNCTION__));
return resolvedAsTypeDecls();
1731}

1733/// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
1734/// a class method in its extension.
1735///
1736void Sema::DiagnoseClassExtensionDupMethods(ObjCCategoryDecl *CAT,
                                          ObjCInterfaceDecl *ID) {
if (!ID)
  return;  // Possibly due to previous error

llvm::DenseMap<Selector, const ObjCMethodDecl*> MethodMap;
for (auto *MD : ID->methods())
  MethodMap[MD->getSelector()] = MD;

if (MethodMap.empty())
  return;
for (const auto *Method : CAT->methods()) {
  const ObjCMethodDecl *&PrevMethod = MethodMap[Method->getSelector()];
  if (PrevMethod &&
      (PrevMethod->isInstanceMethod() == Method->isInstanceMethod()) &&
      !MatchTwoMethodDeclarations(Method, PrevMethod)) {
    Diag(Method->getLocation(), diag::err_duplicate_method_decl)
          << Method->getDeclName();
    Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
  }
}
1757}

1759/// ActOnForwardProtocolDeclaration - Handle \@protocol foo;
1760Sema::DeclGroupPtrTy
1761Sema::ActOnForwardProtocolDeclaration(SourceLocation AtProtocolLoc,
                                    ArrayRef<IdentifierLocPair> IdentList,
                                    const ParsedAttributesView &attrList) {
SmallVector<Decl *, 8> DeclsInGroup;
for (const IdentifierLocPair &IdentPair : IdentList) {
  IdentifierInfo *Ident = IdentPair.first;
  ObjCProtocolDecl *PrevDecl = LookupProtocol(Ident, IdentPair.second,
                                              forRedeclarationInCurContext());
  ObjCProtocolDecl *PDecl
    = ObjCProtocolDecl::Create(Context, CurContext, Ident, 
                               IdentPair.second, AtProtocolLoc,
                               PrevDecl);
      
  PushOnScopeChains(PDecl, TUScope);
  CheckObjCDeclScope(PDecl);

  ProcessDeclAttributeList(TUScope, PDecl, attrList);
  AddPragmaAttributes(TUScope, PDecl);

  if (PrevDecl)
    mergeDeclAttributes(PDecl, PrevDecl);

  DeclsInGroup.push_back(PDecl);
}

return BuildDeclaratorGroup(DeclsInGroup);
1787}

1789Decl *Sema::ActOnStartCategoryInterface(
  SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName,
  SourceLocation ClassLoc, ObjCTypeParamList *typeParamList,
  IdentifierInfo *CategoryName, SourceLocation CategoryLoc,
  Decl *const *ProtoRefs, unsigned NumProtoRefs,
  const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc,
  const ParsedAttributesView &AttrList) {
ObjCCategoryDecl *CDecl;
ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);

/// Check that class of this category is already completely declared.

if (!IDecl 
    || RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
                           diag::err_category_forward_interface,
                           CategoryName == nullptr)) {
  // Create an invalid ObjCCategoryDecl to serve as context for
  // the enclosing method declarations.  We mark the decl invalid
  // to make it clear that this isn't a valid AST.
  CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
                                   ClassLoc, CategoryLoc, CategoryName,
                                   IDecl, typeParamList);
  CDecl->setInvalidDecl();
  CurContext->addDecl(CDecl);
      
  if (!IDecl)
    Diag(ClassLoc, diag::err_undef_interface) << ClassName;
  return ActOnObjCContainerStartDefinition(CDecl);
}

if (!CategoryName && IDecl->getImplementation()) {
  Diag(ClassLoc, diag::err_class_extension_after_impl) << ClassName;
  Diag(IDecl->getImplementation()->getLocation(), 
        diag::note_implementation_declared);
}

if (CategoryName) {
  /// Check for duplicate interface declaration for this category
  if (ObjCCategoryDecl *Previous
        = IDecl->FindCategoryDeclaration(CategoryName)) {
    // Class extensions can be declared multiple times, categories cannot.
    Diag(CategoryLoc, diag::warn_dup_category_def)
      << ClassName << CategoryName;
    Diag(Previous->getLocation(), diag::note_previous_definition);
  }
}

// If we have a type parameter list, check it.
if (typeParamList) {
  if (auto prevTypeParamList = IDecl->getTypeParamList()) {
    if (checkTypeParamListConsistency(*this, prevTypeParamList, typeParamList,
                                      CategoryName
                                        ? TypeParamListContext::Category
                                        : TypeParamListContext::Extension))
      typeParamList = nullptr;
  } else {
    Diag(typeParamList->getLAngleLoc(),
         diag::err_objc_parameterized_category_nonclass)
      << (CategoryName != nullptr)
      << ClassName
      << typeParamList->getSourceRange();

    typeParamList = nullptr;
  }
}

CDecl = ObjCCategoryDecl::Create(Context, CurContext, AtInterfaceLoc,
                                 ClassLoc, CategoryLoc, CategoryName, IDecl,
                                 typeParamList);
// FIXME: PushOnScopeChains?
CurContext->addDecl(CDecl);

// Process the attributes before looking at protocols to ensure that the
// availability attribute is attached to the category to provide availability
// checking for protocol uses.
ProcessDeclAttributeList(TUScope, CDecl, AttrList);
AddPragmaAttributes(TUScope, CDecl);

if (NumProtoRefs) {
  diagnoseUseOfProtocols(*this, CDecl, (ObjCProtocolDecl*const*)ProtoRefs,
                         NumProtoRefs, ProtoLocs);
  CDecl->setProtocolList((ObjCProtocolDecl*const*)ProtoRefs, NumProtoRefs,
                         ProtoLocs, Context);
  // Protocols in the class extension belong to the class.
  if (CDecl->IsClassExtension())
   IDecl->mergeClassExtensionProtocolList((ObjCProtocolDecl*const*)ProtoRefs, 
                                          NumProtoRefs, Context); 
}

CheckObjCDeclScope(CDecl);
return ActOnObjCContainerStartDefinition(CDecl);
1880}

1882/// ActOnStartCategoryImplementation - Perform semantic checks on the
1883/// category implementation declaration and build an ObjCCategoryImplDecl
1884/// object.
1885Decl *Sema::ActOnStartCategoryImplementation(
                    SourceLocation AtCatImplLoc,
                    IdentifierInfo *ClassName, SourceLocation ClassLoc,
                    IdentifierInfo *CatName, SourceLocation CatLoc) {
ObjCInterfaceDecl *IDecl = getObjCInterfaceDecl(ClassName, ClassLoc, true);
ObjCCategoryDecl *CatIDecl = nullptr;
if (IDecl && IDecl->hasDefinition()) {
  CatIDecl = IDecl->FindCategoryDeclaration(CatName);
  if (!CatIDecl) {
    // Category @implementation with no corresponding @interface.
    // Create and install one.
    CatIDecl = ObjCCategoryDecl::Create(Context, CurContext, AtCatImplLoc,
                                        ClassLoc, CatLoc,
                                        CatName, IDecl,
                                        /*typeParamList=*/nullptr);
    CatIDecl->setImplicit();
  }
}

ObjCCategoryImplDecl *CDecl =
  ObjCCategoryImplDecl::Create(Context, CurContext, CatName, IDecl,
                               ClassLoc, AtCatImplLoc, CatLoc);
/// Check that class of this category is already completely declared.
if (!IDecl) {
  Diag(ClassLoc, diag::err_undef_interface) << ClassName;
  CDecl->setInvalidDecl();
} else if (RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
                               diag::err_undef_interface)) {
  CDecl->setInvalidDecl();
}

// FIXME: PushOnScopeChains?
CurContext->addDecl(CDecl);

// If the interface has the objc_runtime_visible attribute, we
// cannot implement a category for it.
if (IDecl && IDecl->hasAttr<ObjCRuntimeVisibleAttr>()) {
  Diag(ClassLoc, diag::err_objc_runtime_visible_category)
    << IDecl->getDeclName();
}

/// Check that CatName, category name, is not used in another implementation.
if (CatIDecl) {
  if (CatIDecl->getImplementation()) {
    Diag(ClassLoc, diag::err_dup_implementation_category) << ClassName
      << CatName;
    Diag(CatIDecl->getImplementation()->getLocation(),
         diag::note_previous_definition);
    CDecl->setInvalidDecl();
  } else {
    CatIDecl->setImplementation(CDecl);
    // Warn on implementating category of deprecated class under 
    // -Wdeprecated-implementations flag.
    DiagnoseObjCImplementedDeprecations(*this, CatIDecl,
                                        CDecl->getLocation());
  }
}

CheckObjCDeclScope(CDecl);
return ActOnObjCContainerStartDefinition(CDecl);
1945}

1947Decl *Sema::ActOnStartClassImplementation(
                    SourceLocation AtClassImplLoc,
                    IdentifierInfo *ClassName, SourceLocation ClassLoc,
                    IdentifierInfo *SuperClassname,
                    SourceLocation SuperClassLoc) {
ObjCInterfaceDecl *IDecl = nullptr;
// Check for another declaration kind with the same name.
NamedDecl *PrevDecl
  = LookupSingleName(TUScope, ClassName, ClassLoc, LookupOrdinaryName,
                     forRedeclarationInCurContext());
if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
  Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;
  Diag(PrevDecl->getLocation(), diag::note_previous_definition);
} else if ((IDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl))) {
  // FIXME: This will produce an error if the definition of the interface has
  // been imported from a module but is not visible.
  RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl),
                      diag::warn_undef_interface);
} else {
  // We did not find anything with the name ClassName; try to correct for
  // typos in the class name.
  TypoCorrection Corrected = CorrectTypo(
      DeclarationNameInfo(ClassName, ClassLoc), LookupOrdinaryName, TUScope,
      nullptr, llvm::make_unique<ObjCInterfaceValidatorCCC>(), CTK_NonError);
  if (Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {
    // Suggest the (potentially) correct interface name. Don't provide a
    // code-modification hint or use the typo name for recovery, because
    // this is just a warning. The program may actually be correct.
    diagnoseTypo(Corrected,
                 PDiag(diag::warn_undef_interface_suggest) << ClassName,
                 /*ErrorRecovery*/false);
  } else {
    Diag(ClassLoc, diag::warn_undef_interface) << ClassName;
  }
}

// Check that super class name is valid class name
ObjCInterfaceDecl *SDecl = nullptr;
if (SuperClassname) {
  // Check if a different kind of symbol declared in this scope.
  PrevDecl = LookupSingleName(TUScope, SuperClassname, SuperClassLoc,
                              LookupOrdinaryName);
  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
    Diag(SuperClassLoc, diag::err_redefinition_different_kind)
      << SuperClassname;
    Diag(PrevDecl->getLocation(), diag::note_previous_definition);
  } else {
    SDecl = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);
    if (SDecl && !SDecl->hasDefinition())
      SDecl = nullptr;
    if (!SDecl)
      Diag(SuperClassLoc, diag::err_undef_superclass)
        << SuperClassname << ClassName;
    else if (IDecl && !declaresSameEntity(IDecl->getSuperClass(), SDecl)) {
      // This implementation and its interface do not have the same
      // super class.
      Diag(SuperClassLoc, diag::err_conflicting_super_class)
        << SDecl->getDeclName();
      Diag(SDecl->getLocation(), diag::note_previous_definition);
    }
  }
}

if (!IDecl) {
  // Legacy case of @implementation with no corresponding @interface.
  // Build, chain & install the interface decl into the identifier.

  // FIXME: Do we support attributes on the @implementation? If so we should
  // copy them over.
  IDecl = ObjCInterfaceDecl::Create(Context, CurContext, AtClassImplLoc,
                                    ClassName, /*typeParamList=*/nullptr,
                                    /*PrevDecl=*/nullptr, ClassLoc,
                                    true);
  AddPragmaAttributes(TUScope, IDecl);
  IDecl->startDefinition();
  if (SDecl) {
    IDecl->setSuperClass(Context.getTrivialTypeSourceInfo(
                           Context.getObjCInterfaceType(SDecl),
                           SuperClassLoc));
    IDecl->setEndOfDefinitionLoc(SuperClassLoc);
  } else {
    IDecl->setEndOfDefinitionLoc(ClassLoc);
  }
  
  PushOnScopeChains(IDecl, TUScope);
} else {
  // Mark the interface as being completed, even if it was just as
  //   @class ....;
  // declaration; the user cannot reopen it.
  if (!IDecl->hasDefinition())
    IDecl->startDefinition();
}

ObjCImplementationDecl* IMPDecl =
  ObjCImplementationDecl::Create(Context, CurContext, IDecl, SDecl,
                                 ClassLoc, AtClassImplLoc, SuperClassLoc);

if (CheckObjCDeclScope(IMPDecl))
  return ActOnObjCContainerStartDefinition(IMPDecl);

// Check that there is no duplicate implementation of this class.
if (IDecl->getImplementation()) {
  // FIXME: Don't leak everything!
  Diag(ClassLoc, diag::err_dup_implementation_class) << ClassName;
  Diag(IDecl->getImplementation()->getLocation(),
       diag::note_previous_definition);
  IMPDecl->setInvalidDecl();
} else { // add it to the list.
  IDecl->setImplementation(IMPDecl);
  PushOnScopeChains(IMPDecl, TUScope);
  // Warn on implementating deprecated class under 
  // -Wdeprecated-implementations flag.
  DiagnoseObjCImplementedDeprecations(*this, IDecl, IMPDecl->getLocation());
}

// If the superclass has the objc_runtime_visible attribute, we
// cannot implement a subclass of it.
if (IDecl->getSuperClass() &&
    IDecl->getSuperClass()->hasAttr<ObjCRuntimeVisibleAttr>()) {
  Diag(ClassLoc, diag::err_objc_runtime_visible_subclass)
    << IDecl->getDeclName()
    << IDecl->getSuperClass()->getDeclName();
}

return ActOnObjCContainerStartDefinition(IMPDecl);
2072}

2074Sema::DeclGroupPtrTy
2075Sema::ActOnFinishObjCImplementation(Decl *ObjCImpDecl, ArrayRef<Decl *> Decls) {
SmallVector<Decl *, 64> DeclsInGroup;
DeclsInGroup.reserve(Decls.size() + 1);

for (unsigned i = 0, e = Decls.size(); i != e; ++i) {
  Decl *Dcl = Decls[i];
  if (!Dcl)
    continue;
  if (Dcl->getDeclContext()->isFileContext())
    Dcl->setTopLevelDeclInObjCContainer();
  DeclsInGroup.push_back(Dcl);
}

DeclsInGroup.push_back(ObjCImpDecl);

return BuildDeclaratorGroup(DeclsInGroup);
2091}

2093void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
                                  ObjCIvarDecl **ivars, unsigned numIvars,
                                  SourceLocation RBrace) {
assert(ImpDecl && "missing implementation decl")(static_cast <bool> (ImpDecl && "missing implementation decl"
) ? void (0) : __assert_fail ("ImpDecl && \"missing implementation decl\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2096, __extension__ __PRETTY_FUNCTION__));
ObjCInterfaceDecl* IDecl = ImpDecl->getClassInterface();
if (!IDecl)
  return;
/// Check case of non-existing \@interface decl.
/// (legacy objective-c \@implementation decl without an \@interface decl).
/// Add implementations's ivar to the synthesize class's ivar list.
if (IDecl->isImplicitInterfaceDecl()) {
  IDecl->setEndOfDefinitionLoc(RBrace);
  // Add ivar's to class's DeclContext.
  for (unsigned i = 0, e = numIvars; i != e; ++i) {
    ivars[i]->setLexicalDeclContext(ImpDecl);
    IDecl->makeDeclVisibleInContext(ivars[i]);
    ImpDecl->addDecl(ivars[i]);
  }
  
  return;
}
// If implementation has empty ivar list, just return.
if (numIvars == 0)
  return;

assert(ivars && "missing @implementation ivars")(static_cast <bool> (ivars && "missing @implementation ivars"
) ? void (0) : __assert_fail ("ivars && \"missing @implementation ivars\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2118, __extension__ __PRETTY_FUNCTION__));
if (LangOpts.ObjCRuntime.isNonFragile()) {
  if (ImpDecl->getSuperClass())
    Diag(ImpDecl->getLocation(), diag::warn_on_superclass_use);
  for (unsigned i = 0; i < numIvars; i++) {
    ObjCIvarDecl* ImplIvar = ivars[i];
    if (const ObjCIvarDecl *ClsIvar = 
          IDecl->getIvarDecl(ImplIvar->getIdentifier())) {
      Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration); 
      Diag(ClsIvar->getLocation(), diag::note_previous_definition);
      continue;
    }
    // Check class extensions (unnamed categories) for duplicate ivars.
    for (const auto *CDecl : IDecl->visible_extensions()) {
      if (const ObjCIvarDecl *ClsExtIvar = 
          CDecl->getIvarDecl(ImplIvar->getIdentifier())) {
        Diag(ImplIvar->getLocation(), diag::err_duplicate_ivar_declaration); 
        Diag(ClsExtIvar->getLocation(), diag::note_previous_definition);
        continue;
      }
    }
    // Instance ivar to Implementation's DeclContext.
    ImplIvar->setLexicalDeclContext(ImpDecl);
    IDecl->makeDeclVisibleInContext(ImplIvar);
    ImpDecl->addDecl(ImplIvar);
  }
  return;
}
// Check interface's Ivar list against those in the implementation.
// names and types must match.
//
unsigned j = 0;
ObjCInterfaceDecl::ivar_iterator
  IVI = IDecl->ivar_begin(), IVE = IDecl->ivar_end();
for (; numIvars > 0 && IVI != IVE; ++IVI) {
  ObjCIvarDecl* ImplIvar = ivars[j++];
  ObjCIvarDecl* ClsIvar = *IVI;
  assert (ImplIvar && "missing implementation ivar")(static_cast <bool> (ImplIvar && "missing implementation ivar"
) ? void (0) : __assert_fail ("ImplIvar && \"missing implementation ivar\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2155, __extension__ __PRETTY_FUNCTION__));
  assert (ClsIvar && "missing class ivar")(static_cast <bool> (ClsIvar && "missing class ivar"
) ? void (0) : __assert_fail ("ClsIvar && \"missing class ivar\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2156, __extension__ __PRETTY_FUNCTION__));

  // First, make sure the types match.
  if (!Context.hasSameType(ImplIvar->getType(), ClsIvar->getType())) {
    Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_type)
      << ImplIvar->getIdentifier()
      << ImplIvar->getType() << ClsIvar->getType();
    Diag(ClsIvar->getLocation(), diag::note_previous_definition);
  } else if (ImplIvar->isBitField() && ClsIvar->isBitField() &&
             ImplIvar->getBitWidthValue(Context) !=
             ClsIvar->getBitWidthValue(Context)) {
    Diag(ImplIvar->getBitWidth()->getLocStart(),
         diag::err_conflicting_ivar_bitwidth) << ImplIvar->getIdentifier();
    Diag(ClsIvar->getBitWidth()->getLocStart(),
         diag::note_previous_definition);
  }
  // Make sure the names are identical.
  if (ImplIvar->getIdentifier() != ClsIvar->getIdentifier()) {
    Diag(ImplIvar->getLocation(), diag::err_conflicting_ivar_name)
      << ImplIvar->getIdentifier() << ClsIvar->getIdentifier();
    Diag(ClsIvar->getLocation(), diag::note_previous_definition);
  }
  --numIvars;
}

if (numIvars > 0)
  Diag(ivars[j]->getLocation(), diag::err_inconsistent_ivar_count);
else if (IVI != IVE)
  Diag(IVI->getLocation(), diag::err_inconsistent_ivar_count);
2185}

2187static void WarnUndefinedMethod(Sema &S, SourceLocation ImpLoc,
                              ObjCMethodDecl *method,
                              bool &IncompleteImpl,
                              unsigned DiagID,
                              NamedDecl *NeededFor = nullptr) {
// No point warning no definition of method which is 'unavailable'.
if (method->getAvailability() == AR_Unavailable)
  return;

// FIXME: For now ignore 'IncompleteImpl'.
// Previously we grouped all unimplemented methods under a single
// warning, but some users strongly voiced that they would prefer
// separate warnings.  We will give that approach a try, as that
// matches what we do with protocols.
{
  const Sema::SemaDiagnosticBuilder &B = S.Diag(ImpLoc, DiagID);
  B << method;
  if (NeededFor)
    B << NeededFor;
}

// Issue a note to the original declaration.
SourceLocation MethodLoc = method->getLocStart();
if (MethodLoc.isValid())
  S.Diag(MethodLoc, diag::note_method_declared_at) << method;
2212}

2214/// Determines if type B can be substituted for type A.  Returns true if we can
2215/// guarantee that anything that the user will do to an object of type A can 
2216/// also be done to an object of type B.  This is trivially true if the two 
2217/// types are the same, or if B is a subclass of A.  It becomes more complex
2218/// in cases where protocols are involved.
2219///
2220/// Object types in Objective-C describe the minimum requirements for an
2221/// object, rather than providing a complete description of a type.  For
2222/// example, if A is a subclass of B, then B* may refer to an instance of A.
2223/// The principle of substitutability means that we may use an instance of A
2224/// anywhere that we may use an instance of B - it will implement all of the
2225/// ivars of B and all of the methods of B.  
2226///
2227/// This substitutability is important when type checking methods, because 
2228/// the implementation may have stricter type definitions than the interface.
2229/// The interface specifies minimum requirements, but the implementation may
2230/// have more accurate ones.  For example, a method may privately accept 
2231/// instances of B, but only publish that it accepts instances of A.  Any
2232/// object passed to it will be type checked against B, and so will implicitly
2233/// by a valid A*.  Similarly, a method may return a subclass of the class that
2234/// it is declared as returning.
2235///
2236/// This is most important when considering subclassing.  A method in a
2237/// subclass must accept any object as an argument that its superclass's
2238/// implementation accepts.  It may, however, accept a more general type
2239/// without breaking substitutability (i.e. you can still use the subclass
2240/// anywhere that you can use the superclass, but not vice versa).  The
2241/// converse requirement applies to return types: the return type for a
2242/// subclass method must be a valid object of the kind that the superclass
2243/// advertises, but it may be specified more accurately.  This avoids the need
2244/// for explicit down-casting by callers.
2245///
2246/// Note: This is a stricter requirement than for assignment.  
2247static bool isObjCTypeSubstitutable(ASTContext &Context,
                                  const ObjCObjectPointerType *A,
                                  const ObjCObjectPointerType *B,
                                  bool rejectId) {
// Reject a protocol-unqualified id.
if (rejectId && B->isObjCIdType()) return false;

// If B is a qualified id, then A must also be a qualified id and it must
// implement all of the protocols in B.  It may not be a qualified class.
// For example, MyClass<A> can be assigned to id<A>, but MyClass<A> is a
// stricter definition so it is not substitutable for id<A>.
if (B->isObjCQualifiedIdType()) {
  return A->isObjCQualifiedIdType() &&
         Context.ObjCQualifiedIdTypesAreCompatible(QualType(A, 0),
                                                   QualType(B,0),
                                                   false);
}

/*
// id is a special type that bypasses type checking completely.  We want a
// warning when it is used in one place but not another.
if (C.isObjCIdType(A) || C.isObjCIdType(B)) return false;


// If B is a qualified id, then A must also be a qualified id (which it isn't
// if we've got this far)
if (B->isObjCQualifiedIdType()) return false;
*/

// Now we know that A and B are (potentially-qualified) class types.  The
// normal rules for assignment apply.
return Context.canAssignObjCInterfaces(A, B);
2279}

2281static SourceRange getTypeRange(TypeSourceInfo *TSI) {
return (TSI ? TSI->getTypeLoc().getSourceRange() : SourceRange());
2283}

2285/// Determine whether two set of Objective-C declaration qualifiers conflict.
2286static bool objcModifiersConflict(Decl::ObjCDeclQualifier x,
                                Decl::ObjCDeclQualifier y) {
return (x & ~Decl::OBJC_TQ_CSNullability) !=
       (y & ~Decl::OBJC_TQ_CSNullability);
2290}

2292static bool CheckMethodOverrideReturn(Sema &S,
                                    ObjCMethodDecl *MethodImpl,
                                    ObjCMethodDecl *MethodDecl,
                                    bool IsProtocolMethodDecl,
                                    bool IsOverridingMode,
                                    bool Warn) {
if (IsProtocolMethodDecl &&
    objcModifiersConflict(MethodDecl->getObjCDeclQualifier(),
                          MethodImpl->getObjCDeclQualifier())) {
  if (Warn) {
    S.Diag(MethodImpl->getLocation(),
           (IsOverridingMode
                ? diag::warn_conflicting_overriding_ret_type_modifiers
                : diag::warn_conflicting_ret_type_modifiers))
        << MethodImpl->getDeclName()
        << MethodImpl->getReturnTypeSourceRange();
    S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration)
        << MethodDecl->getReturnTypeSourceRange();
  }
  else
    return false;
}
if (Warn && IsOverridingMode &&
    !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
    !S.Context.hasSameNullabilityTypeQualifier(MethodImpl->getReturnType(),
                                               MethodDecl->getReturnType(),
                                               false)) {
  auto nullabilityMethodImpl =
    *MethodImpl->getReturnType()->getNullability(S.Context);
  auto nullabilityMethodDecl =
    *MethodDecl->getReturnType()->getNullability(S.Context);
    S.Diag(MethodImpl->getLocation(),
           diag::warn_conflicting_nullability_attr_overriding_ret_types)
      << DiagNullabilityKind(
           nullabilityMethodImpl,
           ((MethodImpl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
            != 0))
      << DiagNullabilityKind(
           nullabilityMethodDecl,
           ((MethodDecl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
              != 0));
    S.Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
}
  
if (S.Context.hasSameUnqualifiedType(MethodImpl->getReturnType(),
                                     MethodDecl->getReturnType()))
  return true;
if (!Warn)
  return false;

unsigned DiagID = 
  IsOverridingMode ? diag::warn_conflicting_overriding_ret_types 
                   : diag::warn_conflicting_ret_types;

// Mismatches between ObjC pointers go into a different warning
// category, and sometimes they're even completely whitelisted.
if (const ObjCObjectPointerType *ImplPtrTy =
        MethodImpl->getReturnType()->getAs<ObjCObjectPointerType>()) {
  if (const ObjCObjectPointerType *IfacePtrTy =
          MethodDecl->getReturnType()->getAs<ObjCObjectPointerType>()) {
    // Allow non-matching return types as long as they don't violate
    // the principle of substitutability.  Specifically, we permit
    // return types that are subclasses of the declared return type,
    // or that are more-qualified versions of the declared type.
    if (isObjCTypeSubstitutable(S.Context, IfacePtrTy, ImplPtrTy, false))
      return false;

    DiagID = 
      IsOverridingMode ? diag::warn_non_covariant_overriding_ret_types 
                       : diag::warn_non_covariant_ret_types;
  }
}

S.Diag(MethodImpl->getLocation(), DiagID)
    << MethodImpl->getDeclName() << MethodDecl->getReturnType()
    << MethodImpl->getReturnType()
    << MethodImpl->getReturnTypeSourceRange();
S.Diag(MethodDecl->getLocation(), IsOverridingMode
                                      ? diag::note_previous_declaration
                                      : diag::note_previous_definition)
    << MethodDecl->getReturnTypeSourceRange();
return false;
2374}

2376static bool CheckMethodOverrideParam(Sema &S,
                                   ObjCMethodDecl *MethodImpl,
                                   ObjCMethodDecl *MethodDecl,
                                   ParmVarDecl *ImplVar,
                                   ParmVarDecl *IfaceVar,
                                   bool IsProtocolMethodDecl,
                                   bool IsOverridingMode,
                                   bool Warn) {
if (IsProtocolMethodDecl &&
    objcModifiersConflict(ImplVar->getObjCDeclQualifier(),
                          IfaceVar->getObjCDeclQualifier())) {
  if (Warn) {
    if (IsOverridingMode)
      S.Diag(ImplVar->getLocation(), 
             diag::warn_conflicting_overriding_param_modifiers)
          << getTypeRange(ImplVar->getTypeSourceInfo())
          << MethodImpl->getDeclName();
    else S.Diag(ImplVar->getLocation(), 
           diag::warn_conflicting_param_modifiers)
        << getTypeRange(ImplVar->getTypeSourceInfo())
        << MethodImpl->getDeclName();
    S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration)
        << getTypeRange(IfaceVar->getTypeSourceInfo());   
  }
  else
    return false;
}
    
QualType ImplTy = ImplVar->getType();
QualType IfaceTy = IfaceVar->getType();
if (Warn && IsOverridingMode &&
    !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) &&
    !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) {
  S.Diag(ImplVar->getLocation(),
         diag::warn_conflicting_nullability_attr_overriding_param_types)
    << DiagNullabilityKind(
         *ImplTy->getNullability(S.Context),
         ((ImplVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
          != 0))
    << DiagNullabilityKind(
         *IfaceTy->getNullability(S.Context),
         ((IfaceVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability)
          != 0));
  S.Diag(IfaceVar->getLocation(), diag::note_previous_declaration);
}
if (S.Context.hasSameUnqualifiedType(ImplTy, IfaceTy))
  return true;

if (!Warn)
  return false;
unsigned DiagID = 
  IsOverridingMode ? diag::warn_conflicting_overriding_param_types 
                   : diag::warn_conflicting_param_types;

// Mismatches between ObjC pointers go into a different warning
// category, and sometimes they're even completely whitelisted.
if (const ObjCObjectPointerType *ImplPtrTy =
      ImplTy->getAs<ObjCObjectPointerType>()) {
  if (const ObjCObjectPointerType *IfacePtrTy =
        IfaceTy->getAs<ObjCObjectPointerType>()) {
    // Allow non-matching argument types as long as they don't
    // violate the principle of substitutability.  Specifically, the
    // implementation must accept any objects that the superclass
    // accepts, however it may also accept others.
    if (isObjCTypeSubstitutable(S.Context, ImplPtrTy, IfacePtrTy, true))
      return false;

    DiagID = 
    IsOverridingMode ? diag::warn_non_contravariant_overriding_param_types 
                     : diag::warn_non_contravariant_param_types;
  }
}

S.Diag(ImplVar->getLocation(), DiagID)
  << getTypeRange(ImplVar->getTypeSourceInfo())
  << MethodImpl->getDeclName() << IfaceTy << ImplTy;
S.Diag(IfaceVar->getLocation(), 
       (IsOverridingMode ? diag::note_previous_declaration 
                         : diag::note_previous_definition))
  << getTypeRange(IfaceVar->getTypeSourceInfo());
return false;
2457}

2459/// In ARC, check whether the conventional meanings of the two methods
2460/// match.  If they don't, it's a hard error.
2461static bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl,
                                    ObjCMethodDecl *decl) {
ObjCMethodFamily implFamily = impl->getMethodFamily();
ObjCMethodFamily declFamily = decl->getMethodFamily();
if (implFamily == declFamily) return false;

// Since conventions are sorted by selector, the only possibility is
// that the types differ enough to cause one selector or the other
// to fall out of the family.
assert(implFamily == OMF_None || declFamily == OMF_None)(static_cast <bool> (implFamily == OMF_None || declFamily
 == OMF_None) ? void (0) : __assert_fail ("implFamily == OMF_None || declFamily == OMF_None"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2470, __extension__ __PRETTY_FUNCTION__));

// No further diagnostics required on invalid declarations.
if (impl->isInvalidDecl() || decl->isInvalidDecl()) return true;

const ObjCMethodDecl *unmatched = impl;
ObjCMethodFamily family = declFamily;
unsigned errorID = diag::err_arc_lost_method_convention;
unsigned noteID = diag::note_arc_lost_method_convention;
if (declFamily == OMF_None) {
  unmatched = decl;
  family = implFamily;
  errorID = diag::err_arc_gained_method_convention;
  noteID = diag::note_arc_gained_method_convention;
}

// Indexes into a %select clause in the diagnostic.
enum FamilySelector {
  F_alloc, F_copy, F_mutableCopy = F_copy, F_init, F_new
};
FamilySelector familySelector = FamilySelector();

switch (family) {
case OMF_None: llvm_unreachable("logic error, no method convention")::llvm::llvm_unreachable_internal("logic error, no method convention"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2493);
case OMF_retain:
case OMF_release:
case OMF_autorelease:
case OMF_dealloc:
case OMF_finalize:
case OMF_retainCount:
case OMF_self:
case OMF_initialize:
case OMF_performSelector:
  // Mismatches for these methods don't change ownership
  // conventions, so we don't care.
  return false;

case OMF_init: familySelector = F_init; break;
case OMF_alloc: familySelector = F_alloc; break;
case OMF_copy: familySelector = F_copy; break;
case OMF_mutableCopy: familySelector = F_mutableCopy; break;
case OMF_new: familySelector = F_new; break;
}

enum ReasonSelector { R_NonObjectReturn, R_UnrelatedReturn };
ReasonSelector reasonSelector;

// The only reason these methods don't fall within their families is
// due to unusual result types.
if (unmatched->getReturnType()->isObjCObjectPointerType()) {
  reasonSelector = R_UnrelatedReturn;
} else {
  reasonSelector = R_NonObjectReturn;
}

S.Diag(impl->getLocation(), errorID) << int(familySelector) << int(reasonSelector);
S.Diag(decl->getLocation(), noteID) << int(familySelector) << int(reasonSelector);

return true;
2529}

2531void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl,
                                     ObjCMethodDecl *MethodDecl,
                                     bool IsProtocolMethodDecl) {
if (getLangOpts().ObjCAutoRefCount &&
    checkMethodFamilyMismatch(*this, ImpMethodDecl, MethodDecl))
  return;

CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl, 
                          IsProtocolMethodDecl, false, 
                          true);

for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
     IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
     EF = MethodDecl->param_end();
     IM != EM && IF != EF; ++IM, ++IF) {
  CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, *IM, *IF,
                           IsProtocolMethodDecl, false, true);
}

if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {
  Diag(ImpMethodDecl->getLocation(), 
       diag::warn_conflicting_variadic);
  Diag(MethodDecl->getLocation(), diag::note_previous_declaration);
}
2555}

2557void Sema::CheckConflictingOverridingMethod(ObjCMethodDecl *Method,
                                     ObjCMethodDecl *Overridden,
                                     bool IsProtocolMethodDecl) {

CheckMethodOverrideReturn(*this, Method, Overridden, 
                          IsProtocolMethodDecl, true, 
                          true);

for (ObjCMethodDecl::param_iterator IM = Method->param_begin(),
     IF = Overridden->param_begin(), EM = Method->param_end(),
     EF = Overridden->param_end();
     IM != EM && IF != EF; ++IM, ++IF) {
  CheckMethodOverrideParam(*this, Method, Overridden, *IM, *IF,
                           IsProtocolMethodDecl, true, true);
}

if (Method->isVariadic() != Overridden->isVariadic()) {
  Diag(Method->getLocation(), 
       diag::warn_conflicting_overriding_variadic);
  Diag(Overridden->getLocation(), diag::note_previous_declaration);
}
2578}

2580/// WarnExactTypedMethods - This routine issues a warning if method
2581/// implementation declaration matches exactly that of its declaration.
2582void Sema::WarnExactTypedMethods(ObjCMethodDecl *ImpMethodDecl,
                               ObjCMethodDecl *MethodDecl,
                               bool IsProtocolMethodDecl) {
// don't issue warning when protocol method is optional because primary
// class is not required to implement it and it is safe for protocol
// to implement it.
if (MethodDecl->getImplementationControl() == ObjCMethodDecl::Optional)
  return;
// don't issue warning when primary class's method is 
// depecated/unavailable.
if (MethodDecl->hasAttr<UnavailableAttr>() ||
    MethodDecl->hasAttr<DeprecatedAttr>())
  return;

bool match = CheckMethodOverrideReturn(*this, ImpMethodDecl, MethodDecl, 
                                    IsProtocolMethodDecl, false, false);
if (match)
  for (ObjCMethodDecl::param_iterator IM = ImpMethodDecl->param_begin(),
       IF = MethodDecl->param_begin(), EM = ImpMethodDecl->param_end(),
       EF = MethodDecl->param_end();
       IM != EM && IF != EF; ++IM, ++IF) {
    match = CheckMethodOverrideParam(*this, ImpMethodDecl, MethodDecl, 
                                     *IM, *IF,
                                     IsProtocolMethodDecl, false, false);
    if (!match)
      break;
  }
if (match)
  match = (ImpMethodDecl->isVariadic() == MethodDecl->isVariadic());
if (match)
  match = !(MethodDecl->isClassMethod() &&
            MethodDecl->getSelector() == GetNullarySelector("load", Context));

if (match) {
  Diag(ImpMethodDecl->getLocation(), 
       diag::warn_category_method_impl_match);
  Diag(MethodDecl->getLocation(), diag::note_method_declared_at)
    << MethodDecl->getDeclName();
}
2621}

2623/// FIXME: Type hierarchies in Objective-C can be deep. We could most likely
2624/// improve the efficiency of selector lookups and type checking by associating
2625/// with each protocol / interface / category the flattened instance tables. If
2626/// we used an immutable set to keep the table then it wouldn't add significant
2627/// memory cost and it would be handy for lookups.

2629typedef llvm::DenseSet<IdentifierInfo*> ProtocolNameSet;
2630typedef std::unique_ptr<ProtocolNameSet> LazyProtocolNameSet;

2632static void findProtocolsWithExplicitImpls(const ObjCProtocolDecl *PDecl,
                                         ProtocolNameSet &PNS) {
if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>())
  PNS.insert(PDecl->getIdentifier());
for (const auto *PI : PDecl->protocols())
  findProtocolsWithExplicitImpls(PI, PNS);
2638}

2640/// Recursively populates a set with all conformed protocols in a class
2641/// hierarchy that have the 'objc_protocol_requires_explicit_implementation'
2642/// attribute.
2643static void findProtocolsWithExplicitImpls(const ObjCInterfaceDecl *Super,
                                         ProtocolNameSet &PNS) {
if (!Super)
  return;

for (const auto *I : Super->all_referenced_protocols())
  findProtocolsWithExplicitImpls(I, PNS);

findProtocolsWithExplicitImpls(Super->getSuperClass(), PNS);
2652}

2654/// CheckProtocolMethodDefs - This routine checks unimplemented methods
2655/// Declared in protocol, and those referenced by it.
2656static void CheckProtocolMethodDefs(Sema &S,
                                  SourceLocation ImpLoc,
                                  ObjCProtocolDecl *PDecl,
                                  bool& IncompleteImpl,
                                  const Sema::SelectorSet &InsMap,
                                  const Sema::SelectorSet &ClsMap,
                                  ObjCContainerDecl *CDecl,
                                  LazyProtocolNameSet &ProtocolsExplictImpl) {
ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl);
ObjCInterfaceDecl *IDecl = C ? C->getClassInterface() 
                             : dyn_cast<ObjCInterfaceDecl>(CDecl);
assert (IDecl && "CheckProtocolMethodDefs - IDecl is null")(static_cast <bool> (IDecl && "CheckProtocolMethodDefs - IDecl is null"
) ? void (0) : __assert_fail ("IDecl && \"CheckProtocolMethodDefs - IDecl is null\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2667, __extension__ __PRETTY_FUNCTION__));

ObjCInterfaceDecl *Super = IDecl->getSuperClass();
ObjCInterfaceDecl *NSIDecl = nullptr;

// If this protocol is marked 'objc_protocol_requires_explicit_implementation'
// then we should check if any class in the super class hierarchy also
// conforms to this protocol, either directly or via protocol inheritance.
// If so, we can skip checking this protocol completely because we
// know that a parent class already satisfies this protocol.
//
// Note: we could generalize this logic for all protocols, and merely
// add the limit on looking at the super class chain for just
// specially marked protocols.  This may be a good optimization.  This
// change is restricted to 'objc_protocol_requires_explicit_implementation'
// protocols for now for controlled evaluation.
if (PDecl->hasAttr<ObjCExplicitProtocolImplAttr>()) {
  if (!ProtocolsExplictImpl) {
    ProtocolsExplictImpl.reset(new ProtocolNameSet);
    findProtocolsWithExplicitImpls(Super, *ProtocolsExplictImpl);
  }
  if (ProtocolsExplictImpl->find(PDecl->getIdentifier()) !=
      ProtocolsExplictImpl->end())
    return;

  // If no super class conforms to the protocol, we should not search
  // for methods in the super class to implicitly satisfy the protocol.
  Super = nullptr;
}

if (S.getLangOpts().ObjCRuntime.isNeXTFamily()) {
  // check to see if class implements forwardInvocation method and objects
  // of this class are derived from 'NSProxy' so that to forward requests
  // from one object to another.
  // Under such conditions, which means that every method possible is
  // implemented in the class, we should not issue "Method definition not
  // found" warnings.
  // FIXME: Use a general GetUnarySelector method for this.
  IdentifierInfo* II = &S.Context.Idents.get("forwardInvocation");
  Selector fISelector = S.Context.Selectors.getSelector(1, &II);
  if (InsMap.count(fISelector))
    // Is IDecl derived from 'NSProxy'? If so, no instance methods
    // need be implemented in the implementation.
    NSIDecl = IDecl->lookupInheritedClass(&S.Context.Idents.get("NSProxy"));
}

// If this is a forward protocol declaration, get its definition.
if (!PDecl->isThisDeclarationADefinition() &&
    PDecl->getDefinition())
  PDecl = PDecl->getDefinition();

// If a method lookup fails locally we still need to look and see if
// the method was implemented by a base class or an inherited
// protocol. This lookup is slow, but occurs rarely in correct code
// and otherwise would terminate in a warning.

// check unimplemented instance methods.
if (!NSIDecl)
  for (auto *method : PDecl->instance_methods()) {
    if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
        !method->isPropertyAccessor() &&
        !InsMap.count(method->getSelector()) &&
        (!Super || !Super->lookupMethod(method->getSelector(),
                                        true /* instance */,
                                        false /* shallowCategory */,
                                        true /* followsSuper */,
                                        nullptr /* category */))) {
          // If a method is not implemented in the category implementation but
          // has been declared in its primary class, superclass,
          // or in one of their protocols, no need to issue the warning. 
          // This is because method will be implemented in the primary class 
          // or one of its super class implementation.
          
          // Ugly, but necessary. Method declared in protocol might have
          // have been synthesized due to a property declared in the class which
          // uses the protocol.
          if (ObjCMethodDecl *MethodInClass =
                IDecl->lookupMethod(method->getSelector(),
                                    true /* instance */,
                                    true /* shallowCategoryLookup */,
                                    false /* followSuper */))
            if (C || MethodInClass->isPropertyAccessor())
              continue;
          unsigned DIAG = diag::warn_unimplemented_protocol_method;
          if (!S.Diags.isIgnored(DIAG, ImpLoc)) {
            WarnUndefinedMethod(S, ImpLoc, method, IncompleteImpl, DIAG,
                                PDecl);
          }
        }
  }
// check unimplemented class methods
for (auto *method : PDecl->class_methods()) {
  if (method->getImplementationControl() != ObjCMethodDecl::Optional &&
      !ClsMap.count(method->getSelector()) &&
      (!Super || !Super->lookupMethod(method->getSelector(),
                                      false /* class method */,
                                      false /* shallowCategoryLookup */,
                                      true  /* followSuper */,
                                      nullptr /* category */))) {
    // See above comment for instance method lookups.
    if (C && IDecl->lookupMethod(method->getSelector(),
                                 false /* class */,
                                 true /* shallowCategoryLookup */,
                                 false /* followSuper */))
      continue;

    unsigned DIAG = diag::warn_unimplemented_protocol_method;
    if (!S.Diags.isIgnored(DIAG, ImpLoc)) {
      WarnUndefinedMethod(S, ImpLoc, method, IncompleteImpl, DIAG, PDecl);
    }
  }
}
// Check on this protocols's referenced protocols, recursively.
for (auto *PI : PDecl->protocols())
  CheckProtocolMethodDefs(S, ImpLoc, PI, IncompleteImpl, InsMap, ClsMap,
                          CDecl, ProtocolsExplictImpl);
2783}

2785/// MatchAllMethodDeclarations - Check methods declared in interface
2786/// or protocol against those declared in their implementations.
2787///
2788void Sema::MatchAllMethodDeclarations(const SelectorSet &InsMap,
                                    const SelectorSet &ClsMap,
                                    SelectorSet &InsMapSeen,
                                    SelectorSet &ClsMapSeen,
                                    ObjCImplDecl* IMPDecl,
                                    ObjCContainerDecl* CDecl,
                                    bool &IncompleteImpl,
                                    bool ImmediateClass,
                                    bool WarnCategoryMethodImpl) {
// Check and see if instance methods in class interface have been
// implemented in the implementation class. If so, their types match.
for (auto *I : CDecl->instance_methods()) {
  if (!InsMapSeen.insert(I->getSelector()).second)
    continue;
  if (!I->isPropertyAccessor() &&
      !InsMap.count(I->getSelector())) {
    if (ImmediateClass)
      WarnUndefinedMethod(*this, IMPDecl->getLocation(), I, IncompleteImpl,
                          diag::warn_undef_method_impl);
    continue;
  } else {
    ObjCMethodDecl *ImpMethodDecl =
      IMPDecl->getInstanceMethod(I->getSelector());
    assert(CDecl->getInstanceMethod(I->getSelector(), true/*AllowHidden*/) &&(static_cast <bool> (CDecl->getInstanceMethod(I->
getSelector(), true ) && "Expected to find the method through lookup as well"
) ? void (0) : __assert_fail ("CDecl->getInstanceMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2812, __extension__ __PRETTY_FUNCTION__))
           "Expected to find the method through lookup as well")(static_cast <bool> (CDecl->getInstanceMethod(I->
getSelector(), true ) && "Expected to find the method through lookup as well"
) ? void (0) : __assert_fail ("CDecl->getInstanceMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2812, __extension__ __PRETTY_FUNCTION__));
    // ImpMethodDecl may be null as in a @dynamic property.
    if (ImpMethodDecl) {
      if (!WarnCategoryMethodImpl)
        WarnConflictingTypedMethods(ImpMethodDecl, I,
                                    isa<ObjCProtocolDecl>(CDecl));
      else if (!I->isPropertyAccessor())
        WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
    }
  }
}

// Check and see if class methods in class interface have been
// implemented in the implementation class. If so, their types match.
for (auto *I : CDecl->class_methods()) {
  if (!ClsMapSeen.insert(I->getSelector()).second)
    continue;
  if (!I->isPropertyAccessor() &&
      !ClsMap.count(I->getSelector())) {
    if (ImmediateClass)
      WarnUndefinedMethod(*this, IMPDecl->getLocation(), I, IncompleteImpl,
                          diag::warn_undef_method_impl);
  } else {
    ObjCMethodDecl *ImpMethodDecl =
      IMPDecl->getClassMethod(I->getSelector());
    assert(CDecl->getClassMethod(I->getSelector(), true/*AllowHidden*/) &&(static_cast <bool> (CDecl->getClassMethod(I->getSelector
(), true ) && "Expected to find the method through lookup as well"
) ? void (0) : __assert_fail ("CDecl->getClassMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2838, __extension__ __PRETTY_FUNCTION__))
           "Expected to find the method through lookup as well")(static_cast <bool> (CDecl->getClassMethod(I->getSelector
(), true ) && "Expected to find the method through lookup as well"
) ? void (0) : __assert_fail ("CDecl->getClassMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2838, __extension__ __PRETTY_FUNCTION__));
    // ImpMethodDecl may be null as in a @dynamic property.
    if (ImpMethodDecl) {
      if (!WarnCategoryMethodImpl)
        WarnConflictingTypedMethods(ImpMethodDecl, I,
                                    isa<ObjCProtocolDecl>(CDecl));
      else if (!I->isPropertyAccessor())
        WarnExactTypedMethods(ImpMethodDecl, I, isa<ObjCProtocolDecl>(CDecl));
    }
  }
}

if (ObjCProtocolDecl *PD = dyn_cast<ObjCProtocolDecl> (CDecl)) {
  // Also, check for methods declared in protocols inherited by
  // this protocol.
  for (auto *PI : PD->protocols())
    MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                               IMPDecl, PI, IncompleteImpl, false,
                               WarnCategoryMethodImpl);
}

if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
  // when checking that methods in implementation match their declaration,
  // i.e. when WarnCategoryMethodImpl is false, check declarations in class
  // extension; as well as those in categories.
  if (!WarnCategoryMethodImpl) {
    for (auto *Cat : I->visible_categories())
      MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                                 IMPDecl, Cat, IncompleteImpl,
                                 ImmediateClass && Cat->IsClassExtension(),
                                 WarnCategoryMethodImpl);
  } else {
    // Also methods in class extensions need be looked at next.
    for (auto *Ext : I->visible_extensions())
      MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                                 IMPDecl, Ext, IncompleteImpl, false,
                                 WarnCategoryMethodImpl);
  }

  // Check for any implementation of a methods declared in protocol.
  for (auto *PI : I->all_referenced_protocols())
    MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                               IMPDecl, PI, IncompleteImpl, false,
                               WarnCategoryMethodImpl);

  // FIXME. For now, we are not checking for extact match of methods 
  // in category implementation and its primary class's super class. 
  if (!WarnCategoryMethodImpl && I->getSuperClass())
    MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                               IMPDecl,
                               I->getSuperClass(), IncompleteImpl, false);
}
2890}

2892/// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
2893/// category matches with those implemented in its primary class and
2894/// warns each time an exact match is found. 
2895void Sema::CheckCategoryVsClassMethodMatches(
                                ObjCCategoryImplDecl *CatIMPDecl) {
// Get category's primary class.
ObjCCategoryDecl *CatDecl = CatIMPDecl->getCategoryDecl();
if (!CatDecl)
  return;
ObjCInterfaceDecl *IDecl = CatDecl->getClassInterface();
if (!IDecl)
  return;
ObjCInterfaceDecl *SuperIDecl = IDecl->getSuperClass();
SelectorSet InsMap, ClsMap;

for (const auto *I : CatIMPDecl->instance_methods()) {
  Selector Sel = I->getSelector();
  // When checking for methods implemented in the category, skip over
  // those declared in category class's super class. This is because
  // the super class must implement the method.
  if (SuperIDecl && SuperIDecl->lookupMethod(Sel, true))
    continue;
  InsMap.insert(Sel);
}

for (const auto *I : CatIMPDecl->class_methods()) {
  Selector Sel = I->getSelector();
  if (SuperIDecl && SuperIDecl->lookupMethod(Sel, false))
    continue;
  ClsMap.insert(Sel);
}
if (InsMap.empty() && ClsMap.empty())
  return;

SelectorSet InsMapSeen, ClsMapSeen;
bool IncompleteImpl = false;
MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                           CatIMPDecl, IDecl,
                           IncompleteImpl, false, 
                           true /*WarnCategoryMethodImpl*/);
2932}

2934void Sema::ImplMethodsVsClassMethods(Scope *S, ObjCImplDecl* IMPDecl,
                                   ObjCContainerDecl* CDecl,
                                   bool IncompleteImpl) {
SelectorSet InsMap;
// Check and see if instance methods in class interface have been
// implemented in the implementation class.
for (const auto *I : IMPDecl->instance_methods())
  InsMap.insert(I->getSelector());

// Add the selectors for getters/setters of @dynamic properties.
for (const auto *PImpl : IMPDecl->property_impls()) {
  // We only care about @dynamic implementations.
  if (PImpl->getPropertyImplementation() != ObjCPropertyImplDecl::Dynamic)
    continue;

  const auto *P = PImpl->getPropertyDecl();
  if (!P) continue;

  InsMap.insert(P->getGetterName());
  if (!P->getSetterName().isNull())
    InsMap.insert(P->getSetterName());
}

// Check and see if properties declared in the interface have either 1)
// an implementation or 2) there is a @synthesize/@dynamic implementation
// of the property in the @implementation.
if (const ObjCInterfaceDecl *IDecl = dyn_cast<ObjCInterfaceDecl>(CDecl)) {
  bool SynthesizeProperties = LangOpts.ObjCDefaultSynthProperties &&
                              LangOpts.ObjCRuntime.isNonFragile() &&
                              !IDecl->isObjCRequiresPropertyDefs();
  DiagnoseUnimplementedProperties(S, IMPDecl, CDecl, SynthesizeProperties);
}

// Diagnose null-resettable synthesized setters.
diagnoseNullResettableSynthesizedSetters(IMPDecl);

SelectorSet ClsMap;
for (const auto *I : IMPDecl->class_methods())
  ClsMap.insert(I->getSelector());

// Check for type conflict of methods declared in a class/protocol and
// its implementation; if any.
SelectorSet InsMapSeen, ClsMapSeen;
MatchAllMethodDeclarations(InsMap, ClsMap, InsMapSeen, ClsMapSeen,
                           IMPDecl, CDecl,
                           IncompleteImpl, true);

// check all methods implemented in category against those declared
// in its primary class.
if (ObjCCategoryImplDecl *CatDecl = 
      dyn_cast<ObjCCategoryImplDecl>(IMPDecl))
  CheckCategoryVsClassMethodMatches(CatDecl);

// Check the protocol list for unimplemented methods in the @implementation
// class.
// Check and see if class methods in class interface have been
// implemented in the implementation class.

LazyProtocolNameSet ExplicitImplProtocols;

if (ObjCInterfaceDecl *I = dyn_cast<ObjCInterfaceDecl> (CDecl)) {
  for (auto *PI : I->all_referenced_protocols())
    CheckProtocolMethodDefs(*this, IMPDecl->getLocation(), PI, IncompleteImpl,
                            InsMap, ClsMap, I, ExplicitImplProtocols);
} else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(CDecl)) {
  // For extended class, unimplemented methods in its protocols will
  // be reported in the primary class.
  if (!C->IsClassExtension()) {
    for (auto *P : C->protocols())
      CheckProtocolMethodDefs(*this, IMPDecl->getLocation(), P,
                              IncompleteImpl, InsMap, ClsMap, CDecl,
                              ExplicitImplProtocols);
    DiagnoseUnimplementedProperties(S, IMPDecl, CDecl,
                                    /*SynthesizeProperties=*/false);
  } 
} else
  llvm_unreachable("invalid ObjCContainerDecl type.")::llvm::llvm_unreachable_internal("invalid ObjCContainerDecl type."
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3010);
3011}

3013Sema::DeclGroupPtrTy
3014Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc,
                                 IdentifierInfo **IdentList,
                                 SourceLocation *IdentLocs,
                                 ArrayRef<ObjCTypeParamList *> TypeParamLists,
                                 unsigned NumElts) {
SmallVector<Decl *, 8> DeclsInGroup;
for (unsigned i = 0; i != NumElts; ++i) {
  // Check for another declaration kind with the same name.
  NamedDecl *PrevDecl
    = LookupSingleName(TUScope, IdentList[i], IdentLocs[i], 
                       LookupOrdinaryName, forRedeclarationInCurContext());
  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {
    // GCC apparently allows the following idiom:
    //
    // typedef NSObject < XCElementTogglerP > XCElementToggler;
    // @class XCElementToggler;
    //
    // Here we have chosen to ignore the forward class declaration
    // with a warning. Since this is the implied behavior.
    TypedefNameDecl *TDD = dyn_cast<TypedefNameDecl>(PrevDecl);
    if (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {
      Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];
      Diag(PrevDecl->getLocation(), diag::note_previous_definition);
    } else {
      // a forward class declaration matching a typedef name of a class refers
      // to the underlying class. Just ignore the forward class with a warning
      // as this will force the intended behavior which is to lookup the
      // typedef name.
      if (isa<ObjCObjectType>(TDD->getUnderlyingType())) {
        Diag(AtClassLoc, diag::warn_forward_class_redefinition)
            << IdentList[i];
        Diag(PrevDecl->getLocation(), diag::note_previous_definition);
        continue;
      }
    }
  }
  
  // Create a declaration to describe this forward declaration.
  ObjCInterfaceDecl *PrevIDecl
    = dyn_cast_or_null<ObjCInterfaceDecl>(PrevDecl);

  IdentifierInfo *ClassName = IdentList[i];
  if (PrevIDecl && PrevIDecl->getIdentifier() != ClassName) {
    // A previous decl with a different name is because of
    // @compatibility_alias, for example:
    // \code
    //   @class NewImage;
    //   @compatibility_alias OldImage NewImage;
    // \endcode
    // A lookup for 'OldImage' will return the 'NewImage' decl.
    //
    // In such a case use the real declaration name, instead of the alias one,
    // otherwise we will break IdentifierResolver and redecls-chain invariants.
    // FIXME: If necessary, add a bit to indicate that this ObjCInterfaceDecl
    // has been aliased.
    ClassName = PrevIDecl->getIdentifier();
  }

  // If this forward declaration has type parameters, compare them with the
  // type parameters of the previous declaration.
  ObjCTypeParamList *TypeParams = TypeParamLists[i];
  if (PrevIDecl && TypeParams) {
    if (ObjCTypeParamList *PrevTypeParams = PrevIDecl->getTypeParamList()) {
      // Check for consistency with the previous declaration.
      if (checkTypeParamListConsistency(
            *this, PrevTypeParams, TypeParams,
            TypeParamListContext::ForwardDeclaration)) {
        TypeParams = nullptr;
      }
    } else if (ObjCInterfaceDecl *Def = PrevIDecl->getDefinition()) {
      // The @interface does not have type parameters. Complain.
      Diag(IdentLocs[i], diag::err_objc_parameterized_forward_class)
        << ClassName
        << TypeParams->getSourceRange();
      Diag(Def->getLocation(), diag::note_defined_here)
        << ClassName;

      TypeParams = nullptr;
    }
  }

  ObjCInterfaceDecl *IDecl
    = ObjCInterfaceDecl::Create(Context, CurContext, AtClassLoc,
                                ClassName, TypeParams, PrevIDecl,
                                IdentLocs[i]);
  IDecl->setAtEndRange(IdentLocs[i]);

  PushOnScopeChains(IDecl, TUScope);
  CheckObjCDeclScope(IDecl);
  DeclsInGroup.push_back(IDecl);
}

return BuildDeclaratorGroup(DeclsInGroup);
3107}

3109static bool tryMatchRecordTypes(ASTContext &Context,
                              Sema::MethodMatchStrategy strategy,
                              const Type *left, const Type *right);

3113static bool matchTypes(ASTContext &Context, Sema::MethodMatchStrategy strategy,
                     QualType leftQT, QualType rightQT) {
const Type *left =
  Context.getCanonicalType(leftQT).getUnqualifiedType().getTypePtr();
const Type *right =
  Context.getCanonicalType(rightQT).getUnqualifiedType().getTypePtr();

if (left == right) return true;

// If we're doing a strict match, the types have to match exactly.
if (strategy == Sema::MMS_strict) return false;

if (left->isIncompleteType() || right->isIncompleteType()) return false;

// Otherwise, use this absurdly complicated algorithm to try to
// validate the basic, low-level compatibility of the two types.

// As a minimum, require the sizes and alignments to match.
TypeInfo LeftTI = Context.getTypeInfo(left);
TypeInfo RightTI = Context.getTypeInfo(right);
if (LeftTI.Width != RightTI.Width)
  return false;

if (LeftTI.Align != RightTI.Align)
  return false;

// Consider all the kinds of non-dependent canonical types:
// - functions and arrays aren't possible as return and parameter types

// - vector types of equal size can be arbitrarily mixed
if (isa<VectorType>(left)) return isa<VectorType>(right);
if (isa<VectorType>(right)) return false;

// - references should only match references of identical type
// - structs, unions, and Objective-C objects must match more-or-less
//   exactly
// - everything else should be a scalar
if (!left->isScalarType() || !right->isScalarType())
  return tryMatchRecordTypes(Context, strategy, left, right);

// Make scalars agree in kind, except count bools as chars, and group
// all non-member pointers together.
Type::ScalarTypeKind leftSK = left->getScalarTypeKind();
Type::ScalarTypeKind rightSK = right->getScalarTypeKind();
if (leftSK == Type::STK_Bool) leftSK = Type::STK_Integral;
if (rightSK == Type::STK_Bool) rightSK = Type::STK_Integral;
if (leftSK == Type::STK_CPointer || leftSK == Type::STK_BlockPointer)
  leftSK = Type::STK_ObjCObjectPointer;
if (rightSK == Type::STK_CPointer || rightSK == Type::STK_BlockPointer)
  rightSK = Type::STK_ObjCObjectPointer;

// Note that data member pointers and function member pointers don't
// intermix because of the size differences.

return (leftSK == rightSK);
3168}

3170static bool tryMatchRecordTypes(ASTContext &Context,
                              Sema::MethodMatchStrategy strategy,
                              const Type *lt, const Type *rt) {
assert(lt && rt && lt != rt)(static_cast <bool> (lt && rt && lt != rt
) ? void (0) : __assert_fail ("lt && rt && lt != rt"
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3173, __extension__ __PRETTY_FUNCTION__));

if (!isa<RecordType>(lt) || !isa<RecordType>(rt)) return false;
RecordDecl *left = cast<RecordType>(lt)->getDecl();
RecordDecl *right = cast<RecordType>(rt)->getDecl();

// Require union-hood to match.
if (left->isUnion() != right->isUnion()) return false;

// Require an exact match if either is non-POD.
if ((isa<CXXRecordDecl>(left) && !cast<CXXRecordDecl>(left)->isPOD()) ||
    (isa<CXXRecordDecl>(right) && !cast<CXXRecordDecl>(right)->isPOD()))
  return false;

// Require size and alignment to match.
TypeInfo LeftTI = Context.getTypeInfo(lt);
TypeInfo RightTI = Context.getTypeInfo(rt);
if (LeftTI.Width != RightTI.Width)
  return false;

if (LeftTI.Align != RightTI.Align)
  return false;

// Require fields to match.
RecordDecl::field_iterator li = left->field_begin(), le = left->field_end();
RecordDecl::field_iterator ri = right->field_begin(), re = right->field_end();
for (; li != le && ri != re; ++li, ++ri) {
  if (!matchTypes(Context, strategy, li->getType(), ri->getType()))
    return false;
}
return (li == le && ri == re);
3204}

3206/// MatchTwoMethodDeclarations - Checks that two methods have matching type and
3207/// returns true, or false, accordingly.
3208/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
3209bool Sema::MatchTwoMethodDeclarations(const ObjCMethodDecl *left,
                                    const ObjCMethodDecl *right,
                                    MethodMatchStrategy strategy) {
if (!matchTypes(Context, strategy, left->getReturnType(),
                right->getReturnType()))
  return false;

// If either is hidden, it is not considered to match.
if (left->isHidden() || right->isHidden())
  return false;

if (getLangOpts().ObjCAutoRefCount &&
    (left->hasAttr<NSReturnsRetainedAttr>()
       != right->hasAttr<NSReturnsRetainedAttr>() ||
     left->hasAttr<NSConsumesSelfAttr>()
       != right->hasAttr<NSConsumesSelfAttr>()))
  return false;

ObjCMethodDecl::param_const_iterator
  li = left->param_begin(), le = left->param_end(), ri = right->param_begin(),
  re = right->param_end();

for (; li != le && ri != re; ++li, ++ri) {
  assert(ri != right->param_end() && "Param mismatch")(static_cast <bool> (ri != right->param_end() &&
 "Param mismatch") ? void (0) : __assert_fail ("ri != right->param_end() && \"Param mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3232, __extension__ __PRETTY_FUNCTION__));
  const ParmVarDecl *lparm = *li, *rparm = *ri;

  if (!matchTypes(Context, strategy, lparm->getType(), rparm->getType()))
    return false;

  if (getLangOpts().ObjCAutoRefCount &&
      lparm->hasAttr<NSConsumedAttr>() != rparm->hasAttr<NSConsumedAttr>())
    return false;
}
return true;
3243}

3245static bool isMethodContextSameForKindofLookup(ObjCMethodDecl *Method,
                                             ObjCMethodDecl *MethodInList) {
auto *MethodProtocol = dyn_cast<ObjCProtocolDecl>(Method->getDeclContext());
auto *MethodInListProtocol =
    dyn_cast<ObjCProtocolDecl>(MethodInList->getDeclContext());
// If this method belongs to a protocol but the method in list does not, or
// vice versa, we say the context is not the same.
if ((MethodProtocol && !MethodInListProtocol) ||
    (!MethodProtocol && MethodInListProtocol))
  return false;

if (MethodProtocol && MethodInListProtocol)
  return true;

ObjCInterfaceDecl *MethodInterface = Method->getClassInterface();
ObjCInterfaceDecl *MethodInListInterface =
    MethodInList->getClassInterface();
return MethodInterface == MethodInListInterface;
3263}

3265void Sema::addMethodToGlobalList(ObjCMethodList *List,
                               ObjCMethodDecl *Method) {
// Record at the head of the list whether there were 0, 1, or >= 2 methods
// inside categories.
if (ObjCCategoryDecl *CD =
        dyn_cast<ObjCCategoryDecl>(Method->getDeclContext()))
  if (!CD->IsClassExtension() && List->getBits() < 2)
    List->setBits(List->getBits() + 1);

// If the list is empty, make it a singleton list.
if (List->getMethod() == nullptr) {
  List->setMethod(Method);
  List->setNext(nullptr);
  return;
}

// We've seen a method with this name, see if we have already seen this type
// signature.
ObjCMethodList *Previous = List;
ObjCMethodList *ListWithSameDeclaration = nullptr;
for (; List; Previous = List, List = List->getNext()) {
  // If we are building a module, keep all of the methods.
  if (getLangOpts().isCompilingModule())
    continue;

  bool SameDeclaration = MatchTwoMethodDeclarations(Method,
                                                    List->getMethod());
  // Looking for method with a type bound requires the correct context exists.
  // We need to insert a method into the list if the context is different.
  // If the method's declaration matches the list
  // a> the method belongs to a different context: we need to insert it, in
  //    order to emit the availability message, we need to prioritize over
  //    availability among the methods with the same declaration.
  // b> the method belongs to the same context: there is no need to insert a
  //    new entry.
  // If the method's declaration does not match the list, we insert it to the
  // end.
  if (!SameDeclaration ||
      !isMethodContextSameForKindofLookup(Method, List->getMethod())) {
    // Even if two method types do not match, we would like to say
    // there is more than one declaration so unavailability/deprecated
    // warning is not too noisy.
    if (!Method->isDefined())
      List->setHasMoreThanOneDecl(true);

    // For methods with the same declaration, the one that is deprecated
    // should be put in the front for better diagnostics.
    if (Method->isDeprecated() && SameDeclaration &&
        !ListWithSameDeclaration && !List->getMethod()->isDeprecated())
      ListWithSameDeclaration = List;

    if (Method->isUnavailable() && SameDeclaration &&
        !ListWithSameDeclaration &&
        List->getMethod()->getAvailability() < AR_Deprecated)
      ListWithSameDeclaration = List;
    continue;
  }

  ObjCMethodDecl *PrevObjCMethod = List->getMethod();

  // Propagate the 'defined' bit.
  if (Method->isDefined())
    PrevObjCMethod->setDefined(true);
  else {
    // Objective-C doesn't allow an @interface for a class after its
    // @implementation. So if Method is not defined and there already is
    // an entry for this type signature, Method has to be for a different
    // class than PrevObjCMethod.
    List->setHasMoreThanOneDecl(true);
  }

  // If a method is deprecated, push it in the global pool.
  // This is used for better diagnostics.
  if (Method->isDeprecated()) {
    if (!PrevObjCMethod->isDeprecated())
      List->setMethod(Method);
  }
  // If the new method is unavailable, push it into global pool
  // unless previous one is deprecated.
  if (Method->isUnavailable()) {
    if (PrevObjCMethod->getAvailability() < AR_Deprecated)
      List->setMethod(Method);
  }

  return;
}

// We have a new signature for an existing method - add it.
// This is extremely rare. Only 1% of Cocoa selectors are "overloaded".
ObjCMethodList *Mem = BumpAlloc.Allocate<ObjCMethodList>();

// We insert it right before ListWithSameDeclaration.
if (ListWithSameDeclaration) {
  auto *List = new (Mem) ObjCMethodList(*ListWithSameDeclaration);
  // FIXME: should we clear the other bits in ListWithSameDeclaration?
  ListWithSameDeclaration->setMethod(Method);
  ListWithSameDeclaration->setNext(List);
  return;
}

Previous->setNext(new (Mem) ObjCMethodList(Method));
3366}

3368/// Read the contents of the method pool for a given selector from
3369/// external storage.
3370void Sema::ReadMethodPool(Selector Sel) {
assert(ExternalSource && "We need an external AST source")(static_cast <bool> (ExternalSource && "We need an external AST source"
) ? void (0) : __assert_fail ("ExternalSource && \"We need an external AST source\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3371, __extension__ __PRETTY_FUNCTION__));
ExternalSource->ReadMethodPool(Sel);
3373}

3375void Sema::updateOutOfDateSelector(Selector Sel) {
if (!ExternalSource)
  return;
ExternalSource->updateOutOfDateSelector(Sel);
3379}

3381void Sema::AddMethodToGlobalPool(ObjCMethodDecl *Method, bool impl,
                               bool instance) {
// Ignore methods of invalid containers.
if (cast<Decl>(Method->getDeclContext())->isInvalidDecl())
  return;

if (ExternalSource)
  ReadMethodPool(Method->getSelector());

GlobalMethodPool::iterator Pos = MethodPool.find(Method->getSelector());
if (Pos == MethodPool.end())
  Pos = MethodPool.insert(std::make_pair(Method->getSelector(),
                                         GlobalMethods())).first;

Method->setDefined(impl);

ObjCMethodList &Entry = instance ? Pos->second.first : Pos->second.second;
addMethodToGlobalList(&Entry, Method);
3399}

3401/// Determines if this is an "acceptable" loose mismatch in the global
3402/// method pool.  This exists mostly as a hack to get around certain
3403/// global mismatches which we can't afford to make warnings / errors.
3404/// Really, what we want is a way to take a method out of the global
3405/// method pool.
3406static bool isAcceptableMethodMismatch(ObjCMethodDecl *chosen,
                                     ObjCMethodDecl *other) {
if (!chosen->isInstanceMethod())
  return false;

Selector sel = chosen->getSelector();
if (!sel.isUnarySelector() || sel.getNameForSlot(0) != "length")
  return false;

// Don't complain about mismatches for -length if the method we
// chose has an integral result type.
return (chosen->getReturnType()->isIntegerType());
3418}

3420/// Return true if the given method is wthin the type bound.
3421static bool FilterMethodsByTypeBound(ObjCMethodDecl *Method,
                                   const ObjCObjectType *TypeBound) {
if (!TypeBound)
  return true;

if (TypeBound->isObjCId())
  // FIXME: should we handle the case of bounding to id<A, B> differently?
  return true;

auto *BoundInterface = TypeBound->getInterface();
assert(BoundInterface && "unexpected object type!")(static_cast <bool> (BoundInterface && "unexpected object type!"
) ? void (0) : __assert_fail ("BoundInterface && \"unexpected object type!\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3431, __extension__ __PRETTY_FUNCTION__));

// Check if the Method belongs to a protocol. We should allow any method
// defined in any protocol, because any subclass could adopt the protocol.
auto *MethodProtocol = dyn_cast<ObjCProtocolDecl>(Method->getDeclContext());
if (MethodProtocol) {
  return true;
}

// If the Method belongs to a class, check if it belongs to the class
// hierarchy of the class bound.
if (ObjCInterfaceDecl *MethodInterface = Method->getClassInterface()) {
  // We allow methods declared within classes that are part of the hierarchy
  // of the class bound (superclass of, subclass of, or the same as the class
  // bound).
  return MethodInterface == BoundInterface ||
         MethodInterface->isSuperClassOf(BoundInterface) ||
         BoundInterface->isSuperClassOf(MethodInterface);
}
llvm_unreachable("unknown method context")::llvm::llvm_unreachable_internal("unknown method context", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3450);
3451}

3453/// We first select the type of the method: Instance or Factory, then collect
3454/// all methods with that type.
3455bool Sema::CollectMultipleMethodsInGlobalPool(
  Selector Sel, SmallVectorImpl<ObjCMethodDecl *> &Methods,
  bool InstanceFirst, bool CheckTheOther,
  const ObjCObjectType *TypeBound) {
if (ExternalSource)
  ReadMethodPool(Sel);

GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
if (Pos == MethodPool.end())
  return false;

// Gather the non-hidden methods.
ObjCMethodList &MethList = InstanceFirst ? Pos->second.first :
                           Pos->second.second;
for (ObjCMethodList *M = &MethList; M; M = M->getNext())
  if (M->getMethod() && !M->getMethod()->isHidden()) {
    if (FilterMethodsByTypeBound(M->getMethod(), TypeBound))
      Methods.push_back(M->getMethod());
  }

// Return if we find any method with the desired kind.
if (!Methods.empty())
  return Methods.size() > 1;

if (!CheckTheOther)
  return false;

// Gather the other kind.
ObjCMethodList &MethList2 = InstanceFirst ? Pos->second.second :
                            Pos->second.first;
for (ObjCMethodList *M = &MethList2; M; M = M->getNext())
  if (M->getMethod() && !M->getMethod()->isHidden()) {
    if (FilterMethodsByTypeBound(M->getMethod(), TypeBound))
      Methods.push_back(M->getMethod());
  }

return Methods.size() > 1;
3492}

3494bool Sema::AreMultipleMethodsInGlobalPool(
  Selector Sel, ObjCMethodDecl *BestMethod, SourceRange R,
  bool receiverIdOrClass, SmallVectorImpl<ObjCMethodDecl *> &Methods) {
// Diagnose finding more than one method in global pool.
SmallVector<ObjCMethodDecl *, 4> FilteredMethods;
FilteredMethods.push_back(BestMethod);

for (auto *M : Methods)
  if (M != BestMethod && !M->hasAttr<UnavailableAttr>())
    FilteredMethods.push_back(M);

if (FilteredMethods.size() > 1)
  DiagnoseMultipleMethodInGlobalPool(FilteredMethods, Sel, R,
                                     receiverIdOrClass);

GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
// Test for no method in the pool which should not trigger any warning by
// caller.
if (Pos == MethodPool.end())
  return true;
ObjCMethodList &MethList =
  BestMethod->isInstanceMethod() ? Pos->second.first : Pos->second.second;
return MethList.hasMoreThanOneDecl();
3517}

3519ObjCMethodDecl *Sema::LookupMethodInGlobalPool(Selector Sel, SourceRange R,
                                             bool receiverIdOrClass,
                                             bool instance) {
if (ExternalSource)
  ReadMethodPool(Sel);
  
GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
if (Pos == MethodPool.end())
  return nullptr;

// Gather the non-hidden methods.
ObjCMethodList &MethList = instance ? Pos->second.first : Pos->second.second;
SmallVector<ObjCMethodDecl *, 4> Methods;
for (ObjCMethodList *M = &MethList; M; M = M->getNext()) {
  if (M->getMethod() && !M->getMethod()->isHidden())
    return M->getMethod();
}
return nullptr;
3537}

3539void Sema::DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl*> &Methods,
                                            Selector Sel, SourceRange R,
                                            bool receiverIdOrClass) {
// We found multiple methods, so we may have to complain.
bool issueDiagnostic = false, issueError = false;

// We support a warning which complains about *any* difference in
// method signature.
bool strictSelectorMatch =
receiverIdOrClass &&
!Diags.isIgnored(diag::warn_strict_multiple_method_decl, R.getBegin());
if (strictSelectorMatch) {
  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
    if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_strict)) {
      issueDiagnostic = true;
      break;
    }
  }
}

// If we didn't see any strict differences, we won't see any loose
// differences.  In ARC, however, we also need to check for loose
// mismatches, because most of them are errors.
if (!strictSelectorMatch ||
    (issueDiagnostic && getLangOpts().ObjCAutoRefCount))
  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
    // This checks if the methods differ in type mismatch.
    if (!MatchTwoMethodDeclarations(Methods[0], Methods[I], MMS_loose) &&
        !isAcceptableMethodMismatch(Methods[0], Methods[I])) {
      issueDiagnostic = true;
      if (getLangOpts().ObjCAutoRefCount)
        issueError = true;
      break;
    }
  }

if (issueDiagnostic) {
  if (issueError)
    Diag(R.getBegin(), diag::err_arc_multiple_method_decl) << Sel << R;
  else if (strictSelectorMatch)
    Diag(R.getBegin(), diag::warn_strict_multiple_method_decl) << Sel << R;
  else
    Diag(R.getBegin(), diag::warn_multiple_method_decl) << Sel << R;
  
  Diag(Methods[0]->getLocStart(),
       issueError ? diag::note_possibility : diag::note_using)
  << Methods[0]->getSourceRange();
  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
    Diag(Methods[I]->getLocStart(), diag::note_also_found)
    << Methods[I]->getSourceRange();
  }
}
3591}

3593ObjCMethodDecl *Sema::LookupImplementedMethodInGlobalPool(Selector Sel) {
GlobalMethodPool::iterator Pos = MethodPool.find(Sel);
if (Pos == MethodPool.end())
  return nullptr;

GlobalMethods &Methods = Pos->second;
for (const ObjCMethodList *Method = &Methods.first; Method;
     Method = Method->getNext())
  if (Method->getMethod() &&
      (Method->getMethod()->isDefined() ||
       Method->getMethod()->isPropertyAccessor()))
    return Method->getMethod();

for (const ObjCMethodList *Method = &Methods.second; Method;
     Method = Method->getNext())
  if (Method->getMethod() &&
      (Method->getMethod()->isDefined() ||
       Method->getMethod()->isPropertyAccessor()))
    return Method->getMethod();
return nullptr;
3613}

3615static void
3616HelperSelectorsForTypoCorrection(
                    SmallVectorImpl<const ObjCMethodDecl *> &BestMethod,
                    StringRef Typo, const ObjCMethodDecl * Method) {
const unsigned MaxEditDistance = 1;
unsigned BestEditDistance = MaxEditDistance + 1;
std::string MethodName = Method->getSelector().getAsString();

unsigned MinPossibleEditDistance = abs((int)MethodName.size() - (int)Typo.size());
if (MinPossibleEditDistance > 0 &&
    Typo.size() / MinPossibleEditDistance < 1)
  return;
unsigned EditDistance = Typo.edit_distance(MethodName, true, MaxEditDistance);
if (EditDistance > MaxEditDistance)
  return;
if (EditDistance == BestEditDistance)
  BestMethod.push_back(Method);
else if (EditDistance < BestEditDistance) {
  BestMethod.clear();
  BestMethod.push_back(Method);
}
3636}

3638static bool HelperIsMethodInObjCType(Sema &S, Selector Sel,
                                   QualType ObjectType) {
if (ObjectType.isNull())
  return true;
if (S.LookupMethodInObjectType(Sel, ObjectType, true/*Instance method*/))
  return true;
return S.LookupMethodInObjectType(Sel, ObjectType, false/*Class method*/) !=
       nullptr;
3646}

3648const ObjCMethodDecl *
3649Sema::SelectorsForTypoCorrection(Selector Sel,
                               QualType ObjectType) {
unsigned NumArgs = Sel.getNumArgs();
SmallVector<const ObjCMethodDecl *, 8> Methods;
bool ObjectIsId = true, ObjectIsClass = true;
if (ObjectType.isNull())
  ObjectIsId = ObjectIsClass = false;
else if (!ObjectType->isObjCObjectPointerType())
  return nullptr;
else if (const ObjCObjectPointerType *ObjCPtr =
         ObjectType->getAsObjCInterfacePointerType()) {
  ObjectType = QualType(ObjCPtr->getInterfaceType(), 0);
  ObjectIsId = ObjectIsClass = false;
}
else if (ObjectType->isObjCIdType() || ObjectType->isObjCQualifiedIdType())
  ObjectIsClass = false;
else if (ObjectType->isObjCClassType() || ObjectType->isObjCQualifiedClassType())
  ObjectIsId = false;
else
  return nullptr;

for (GlobalMethodPool::iterator b = MethodPool.begin(),
     e = MethodPool.end(); b != e; b++) {
  // instance methods
  for (ObjCMethodList *M = &b->second.first; M; M=M->getNext())
    if (M->getMethod() &&
        (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
        (M->getMethod()->getSelector() != Sel)) {
      if (ObjectIsId)
        Methods.push_back(M->getMethod());
      else if (!ObjectIsClass &&
               HelperIsMethodInObjCType(*this, M->getMethod()->getSelector(),
                                        ObjectType))
        Methods.push_back(M->getMethod());
    }
  // class methods
  for (ObjCMethodList *M = &b->second.second; M; M=M->getNext())
    if (M->getMethod() &&
        (M->getMethod()->getSelector().getNumArgs() == NumArgs) &&
        (M->getMethod()->getSelector() != Sel)) {
      if (ObjectIsClass)
        Methods.push_back(M->getMethod());
      else if (!ObjectIsId &&
               HelperIsMethodInObjCType(*this, M->getMethod()->getSelector(),
                                        ObjectType))
        Methods.push_back(M->getMethod());
    }
}

SmallVector<const ObjCMethodDecl *, 8> SelectedMethods;
for (unsigned i = 0, e = Methods.size(); i < e; i++) {
  HelperSelectorsForTypoCorrection(SelectedMethods,
                                   Sel.getAsString(), Methods[i]);
}
return (SelectedMethods.size() == 1) ? SelectedMethods[0] : nullptr;
3704}

3706/// DiagnoseDuplicateIvars -
3707/// Check for duplicate ivars in the entire class at the start of 
3708/// \@implementation. This becomes necesssary because class extension can
3709/// add ivars to a class in random order which will not be known until
3710/// class's \@implementation is seen.
3711void Sema::DiagnoseDuplicateIvars(ObjCInterfaceDecl *ID, 
                                ObjCInterfaceDecl *SID) {
for (auto *Ivar : ID->ivars()) {
  if (Ivar->isInvalidDecl())
    continue;
  if (IdentifierInfo *II = Ivar->getIdentifier()) {
    ObjCIvarDecl* prevIvar = SID->lookupInstanceVariable(II);
    if (prevIvar) {
      Diag(Ivar->getLocation(), diag::err_duplicate_member) << II;
      Diag(prevIvar->getLocation(), diag::note_previous_declaration);
      Ivar->setInvalidDecl();
    }
  }
}
3725}

3727/// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.
3728static void DiagnoseWeakIvars(Sema &S, ObjCImplementationDecl *ID) {
if (S.getLangOpts().ObjCWeak) return;

for (auto ivar = ID->getClassInterface()->all_declared_ivar_begin();
       ivar; ivar = ivar->getNextIvar()) {
  if (ivar->isInvalidDecl()) continue;
  if (ivar->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {
    if (S.getLangOpts().ObjCWeakRuntime) {
      S.Diag(ivar->getLocation(), diag::err_arc_weak_disabled);
    } else {
      S.Diag(ivar->getLocation(), diag::err_arc_weak_no_runtime);
    }
  }
}
3742}

3744/// Diagnose attempts to use flexible array member with retainable object type.
3745static void DiagnoseRetainableFlexibleArrayMember(Sema &S,
                                                ObjCInterfaceDecl *ID) {
if (!S.getLangOpts().ObjCAutoRefCount)
  return;

for (auto ivar = ID->all_declared_ivar_begin(); ivar;
     ivar = ivar->getNextIvar()) {
  if (ivar->isInvalidDecl())
    continue;
  QualType IvarTy = ivar->getType();
  if (IvarTy->isIncompleteArrayType() &&
      (IvarTy.getObjCLifetime() != Qualifiers::OCL_ExplicitNone) &&
      IvarTy->isObjCLifetimeType()) {
    S.Diag(ivar->getLocation(), diag::err_flexible_array_arc_retainable);
    ivar->setInvalidDecl();
  }
}
3762}

3764Sema::ObjCContainerKind Sema::getObjCContainerKind() const {
switch (CurContext->getDeclKind()) {
  case Decl::ObjCInterface:
    return Sema::OCK_Interface;
  case Decl::ObjCProtocol:
    return Sema::OCK_Protocol;
  case Decl::ObjCCategory:
    if (cast<ObjCCategoryDecl>(CurContext)->IsClassExtension())
      return Sema::OCK_ClassExtension;
    return Sema::OCK_Category;
  case Decl::ObjCImplementation:
    return Sema::OCK_Implementation;
  case Decl::ObjCCategoryImpl:
    return Sema::OCK_CategoryImplementation;

  default:
    return Sema::OCK_None;
}
3782}

3784static bool IsVariableSizedType(QualType T) {
if (T->isIncompleteArrayType())
  return true;
const auto *RecordTy = T->getAs<RecordType>();
return (RecordTy && RecordTy->getDecl()->hasFlexibleArrayMember());
3789}

3791static void DiagnoseVariableSizedIvars(Sema &S, ObjCContainerDecl *OCD) {
ObjCInterfaceDecl *IntfDecl = nullptr;
ObjCInterfaceDecl::ivar_range Ivars = llvm::make_range(
    ObjCInterfaceDecl::ivar_iterator(), ObjCInterfaceDecl::ivar_iterator());
if ((IntfDecl = dyn_cast<ObjCInterfaceDecl>(OCD))) {
  Ivars = IntfDecl->ivars();
} else if (auto *ImplDecl = dyn_cast<ObjCImplementationDecl>(OCD)) {
  IntfDecl = ImplDecl->getClassInterface();
  Ivars = ImplDecl->ivars();
} else if (auto *CategoryDecl = dyn_cast<ObjCCategoryDecl>(OCD)) {
  if (CategoryDecl->IsClassExtension()) {
    IntfDecl = CategoryDecl->getClassInterface();
    Ivars = CategoryDecl->ivars();
  }
}

// Check if variable sized ivar is in interface and visible to subclasses.
if (!isa<ObjCInterfaceDecl>(OCD)) {
  for (auto ivar : Ivars) {
    if (!ivar->isInvalidDecl() && IsVariableSizedType(ivar->getType())) {
      S.Diag(ivar->getLocation(), diag::warn_variable_sized_ivar_visibility)
          << ivar->getDeclName() << ivar->getType();
    }
  }
}

// Subsequent checks require interface decl.
if (!IntfDecl)
  return;

// Check if variable sized ivar is followed by another ivar.
for (ObjCIvarDecl *ivar = IntfDecl->all_declared_ivar_begin(); ivar;
     ivar = ivar->getNextIvar()) {
  if (ivar->isInvalidDecl() || !ivar->getNextIvar())
    continue;
  QualType IvarTy = ivar->getType();
  bool IsInvalidIvar = false;
  if (IvarTy->isIncompleteArrayType()) {
    S.Diag(ivar->getLocation(), diag::err_flexible_array_not_at_end)
        << ivar->getDeclName() << IvarTy
        << TTK_Class; // Use "class" for Obj-C.
    IsInvalidIvar = true;
  } else if (const RecordType *RecordTy = IvarTy->getAs<RecordType>()) {
    if (RecordTy->getDecl()->hasFlexibleArrayMember()) {
      S.Diag(ivar->getLocation(),
             diag::err_objc_variable_sized_type_not_at_end)
          << ivar->getDeclName() << IvarTy;
      IsInvalidIvar = true;
    }
  }
  if (IsInvalidIvar) {
    S.Diag(ivar->getNextIvar()->getLocation(),
           diag::note_next_ivar_declaration)
        << ivar->getNextIvar()->getSynthesize();
    ivar->setInvalidDecl();
  }
}

// Check if ObjC container adds ivars after variable sized ivar in superclass.
// Perform the check only if OCD is the first container to declare ivars to
// avoid multiple warnings for the same ivar.
ObjCIvarDecl *FirstIvar =
    (Ivars.begin() == Ivars.end()) ? nullptr : *Ivars.begin();
if (FirstIvar && (FirstIvar == IntfDecl->all_declared_ivar_begin())) {
  const ObjCInterfaceDecl *SuperClass = IntfDecl->getSuperClass();
  while (SuperClass && SuperClass->ivar_empty())
    SuperClass = SuperClass->getSuperClass();
  if (SuperClass) {
    auto IvarIter = SuperClass->ivar_begin();
    std::advance(IvarIter, SuperClass->ivar_size() - 1);
    const ObjCIvarDecl *LastIvar = *IvarIter;
    if (IsVariableSizedType(LastIvar->getType())) {
      S.Diag(FirstIvar->getLocation(),
             diag::warn_superclass_variable_sized_type_not_at_end)
          << FirstIvar->getDeclName() << LastIvar->getDeclName()
          << LastIvar->getType() << SuperClass->getDeclName();
      S.Diag(LastIvar->getLocation(), diag::note_entity_declared_at)
          << LastIvar->getDeclName();
    }
  }
}
3872}

3874// Note: For class/category implementations, allMethods is always null.
3875Decl *Sema::ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef<Decl *> allMethods,
                     ArrayRef<DeclGroupPtrTy> allTUVars) {
if (getObjCContainerKind() == Sema::OCK_None)
  return nullptr;

assert(AtEnd.isValid() && "Invalid location for '@end'")(static_cast <bool> (AtEnd.isValid() && "Invalid location for '@end'"
) ? void (0) : __assert_fail ("AtEnd.isValid() && \"Invalid location for '@end'\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3880, __extension__ __PRETTY_FUNCTION__));

auto *OCD = cast<ObjCContainerDecl>(CurContext);
Decl *ClassDecl = OCD;

bool isInterfaceDeclKind =
      isa<ObjCInterfaceDecl>(ClassDecl) || isa<ObjCCategoryDecl>(ClassDecl)
       || isa<ObjCProtocolDecl>(ClassDecl);
bool checkIdenticalMethods = isa<ObjCImplementationDecl>(ClassDecl);

// FIXME: Remove these and use the ObjCContainerDecl/DeclContext.
llvm::DenseMap<Selector, const ObjCMethodDecl*> InsMap;
llvm::DenseMap<Selector, const ObjCMethodDecl*> ClsMap;

for (unsigned i = 0, e = allMethods.size(); i != e; i++ ) {
  ObjCMethodDecl *Method =
    cast_or_null<ObjCMethodDecl>(allMethods[i]);

  if (!Method) continue;  // Already issued a diagnostic.
  if (Method->isInstanceMethod()) {
    /// Check for instance method of the same name with incompatible types
    const ObjCMethodDecl *&PrevMethod = InsMap[Method->getSelector()];
    bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
                            : false;
    if ((isInterfaceDeclKind && PrevMethod && !match)
        || (checkIdenticalMethods && match)) {
        Diag(Method->getLocation(), diag::err_duplicate_method_decl)
          << Method->getDeclName();
        Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
      Method->setInvalidDecl();
    } else {
      if (PrevMethod) {
        Method->setAsRedeclaration(PrevMethod);
        if (!Context.getSourceManager().isInSystemHeader(
               Method->getLocation()))
          Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
            << Method->getDeclName();
        Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
      }
      InsMap[Method->getSelector()] = Method;
      /// The following allows us to typecheck messages to "id".
      AddInstanceMethodToGlobalPool(Method);
    }
  } else {
    /// Check for class method of the same name with incompatible types
    const ObjCMethodDecl *&PrevMethod = ClsMap[Method->getSelector()];
    bool match = PrevMethod ? MatchTwoMethodDeclarations(Method, PrevMethod)
                            : false;
    if ((isInterfaceDeclKind && PrevMethod && !match)
        || (checkIdenticalMethods && match)) {
      Diag(Method->getLocation(), diag::err_duplicate_method_decl)
        << Method->getDeclName();
      Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
      Method->setInvalidDecl();
    } else {
      if (PrevMethod) {
        Method->setAsRedeclaration(PrevMethod);
        if (!Context.getSourceManager().isInSystemHeader(
               Method->getLocation()))
          Diag(Method->getLocation(), diag::warn_duplicate_method_decl)
            << Method->getDeclName();
        Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
      }
      ClsMap[Method->getSelector()] = Method;
      AddFactoryMethodToGlobalPool(Method);
    }
  }
}
if (isa<ObjCInterfaceDecl>(ClassDecl)) {
  // Nothing to do here.
} else if (ObjCCategoryDecl *C = dyn_cast<ObjCCategoryDecl>(ClassDecl)) {
  // Categories are used to extend the class by declaring new methods.
  // By the same token, they are also used to add new properties. No
  // need to compare the added property to those in the class.

  if (C->IsClassExtension()) {
    ObjCInterfaceDecl *CCPrimary = C->getClassInterface();
    DiagnoseClassExtensionDupMethods(C, CCPrimary);
  }
}
if (ObjCContainerDecl *CDecl = dyn_cast<ObjCContainerDecl>(ClassDecl)) {
  if (CDecl->getIdentifier())
    // ProcessPropertyDecl is responsible for diagnosing conflicts with any
    // user-defined setter/getter. It also synthesizes setter/getter methods
    // and adds them to the DeclContext and global method pools.
    for (auto *I : CDecl->properties())
      ProcessPropertyDecl(I);
  CDecl->setAtEndRange(AtEnd);
}
if (ObjCImplementationDecl *IC=dyn_cast<ObjCImplementationDecl>(ClassDecl)) {
  IC->setAtEndRange(AtEnd);
  if (ObjCInterfaceDecl* IDecl = IC->getClassInterface()) {
    // Any property declared in a class extension might have user
    // declared setter or getter in current class extension or one
    // of the other class extensions. Mark them as synthesized as
    // property will be synthesized when property with same name is
    // seen in the @implementation.
    for (const auto *Ext : IDecl->visible_extensions()) {
      for (const auto *Property : Ext->instance_properties()) {
        // Skip over properties declared @dynamic
        if (const ObjCPropertyImplDecl *PIDecl
            = IC->FindPropertyImplDecl(Property->getIdentifier(),
                                       Property->getQueryKind()))
          if (PIDecl->getPropertyImplementation() 
                == ObjCPropertyImplDecl::Dynamic)
            continue;

        for (const auto *Ext : IDecl->visible_extensions()) {
          if (ObjCMethodDecl *GetterMethod
                = Ext->getInstanceMethod(Property->getGetterName()))
            GetterMethod->setPropertyAccessor(true);
          if (!Property->isReadOnly())
            if (ObjCMethodDecl *SetterMethod
                  = Ext->getInstanceMethod(Property->getSetterName()))
              SetterMethod->setPropertyAccessor(true);
        }
      }
    }
    ImplMethodsVsClassMethods(S, IC, IDecl);
    AtomicPropertySetterGetterRules(IC, IDecl);
    DiagnoseOwningPropertyGetterSynthesis(IC);
    DiagnoseUnusedBackingIvarInAccessor(S, IC);
    if (IDecl->hasDesignatedInitializers())
      DiagnoseMissingDesignatedInitOverrides(IC, IDecl);
    DiagnoseWeakIvars(*this, IC);
    DiagnoseRetainableFlexibleArrayMember(*this, IDecl);

    bool HasRootClassAttr = IDecl->hasAttr<ObjCRootClassAttr>();
    if (IDecl->getSuperClass() == nullptr) {
      // This class has no superclass, so check that it has been marked with
      // __attribute((objc_root_class)).
      if (!HasRootClassAttr) {
        SourceLocation DeclLoc(IDecl->getLocation());
        SourceLocation SuperClassLoc(getLocForEndOfToken(DeclLoc));
        Diag(DeclLoc, diag::warn_objc_root_class_missing)
          << IDecl->getIdentifier();
        // See if NSObject is in the current scope, and if it is, suggest
        // adding " : NSObject " to the class declaration.
        NamedDecl *IF = LookupSingleName(TUScope,
                                         NSAPIObj->getNSClassId(NSAPI::ClassId_NSObject),
                                         DeclLoc, LookupOrdinaryName);
        ObjCInterfaceDecl *NSObjectDecl = dyn_cast_or_null<ObjCInterfaceDecl>(IF);
        if (NSObjectDecl && NSObjectDecl->getDefinition()) {
          Diag(SuperClassLoc, diag::note_objc_needs_superclass)
            << FixItHint::CreateInsertion(SuperClassLoc, " : NSObject ");
        } else {
          Diag(SuperClassLoc, diag::note_objc_needs_superclass);
        }
      }
    } else if (HasRootClassAttr) {
      // Complain that only root classes may have this attribute.
      Diag(IDecl->getLocation(), diag::err_objc_root_class_subclass);
    }

    if (const ObjCInterfaceDecl *Super = IDecl->getSuperClass()) {
      // An interface can subclass another interface with a
      // objc_subclassing_restricted attribute when it has that attribute as
      // well (because of interfaces imported from Swift). Therefore we have
      // to check if we can subclass in the implementation as well.
      if (IDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
          Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
        Diag(IC->getLocation(), diag::err_restricted_superclass_mismatch);
        Diag(Super->getLocation(), diag::note_class_declared);
      }
    }

    if (LangOpts.ObjCRuntime.isNonFragile()) {
      while (IDecl->getSuperClass()) {
        DiagnoseDuplicateIvars(IDecl, IDecl->getSuperClass());
        IDecl = IDecl->getSuperClass();
      }
    }
  }
  SetIvarInitializers(IC);
} else if (ObjCCategoryImplDecl* CatImplClass =
                                 dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {
  CatImplClass->setAtEndRange(AtEnd);

  // Find category interface decl and then check that all methods declared
  // in this interface are implemented in the category @implementation.
  if (ObjCInterfaceDecl* IDecl = CatImplClass->getClassInterface()) {
    if (ObjCCategoryDecl *Cat
          = IDecl->FindCategoryDeclaration(CatImplClass->getIdentifier())) {
      ImplMethodsVsClassMethods(S, CatImplClass, Cat);
    }
  }
} else if (const auto *IntfDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {
  if (const ObjCInterfaceDecl *Super = IntfDecl->getSuperClass()) {
    if (!IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>() &&
        Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {
      Diag(IntfDecl->getLocation(), diag::err_restricted_superclass_mismatch);
      Diag(Super->getLocation(), diag::note_class_declared);
    }
  }
}
DiagnoseVariableSizedIvars(*this, OCD);
if (isInterfaceDeclKind) {
  // Reject invalid vardecls.
  for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
    DeclGroupRef DG = allTUVars[i].get();
    for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
      if (VarDecl *VDecl = dyn_cast<VarDecl>(*I)) {
        if (!VDecl->hasExternalStorage())
          Diag(VDecl->getLocation(), diag::err_objc_var_decl_inclass);
      }
  }
}
ActOnObjCContainerFinishDefinition();

for (unsigned i = 0, e = allTUVars.size(); i != e; i++) {
  DeclGroupRef DG = allTUVars[i].get();
  for (DeclGroupRef::iterator I = DG.begin(), E = DG.end(); I != E; ++I)
    (*I)->setTopLevelDeclInObjCContainer();
  Consumer.HandleTopLevelDeclInObjCContainer(DG);
}

ActOnDocumentableDecl(ClassDecl);
return ClassDecl;
4098}

4100/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
4101/// objective-c's type qualifier from the parser version of the same info.
4102static Decl::ObjCDeclQualifier
4103CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
4105}

4107/// Check whether the declared result type of the given Objective-C
4108/// method declaration is compatible with the method's class.
4109///
4110static Sema::ResultTypeCompatibilityKind 
4111CheckRelatedResultTypeCompatibility(Sema &S, ObjCMethodDecl *Method,
                                  ObjCInterfaceDecl *CurrentClass) {
QualType ResultType = Method->getReturnType();

// If an Objective-C method inherits its related result type, then its 
// declared result type must be compatible with its own class type. The
// declared result type is compatible if:
if (const ObjCObjectPointerType *ResultObjectType
                              = ResultType->getAs<ObjCObjectPointerType>()) {
  //   - it is id or qualified id, or
  if (ResultObjectType->isObjCIdType() ||
      ResultObjectType->isObjCQualifiedIdType())
    return Sema::RTC_Compatible;

  if (CurrentClass) {
    if (ObjCInterfaceDecl *ResultClass 
                                    = ResultObjectType->getInterfaceDecl()) {
      //   - it is the same as the method's class type, or
      if (declaresSameEntity(CurrentClass, ResultClass))
        return Sema::RTC_Compatible;
      
      //   - it is a superclass of the method's class type
      if (ResultClass->isSuperClassOf(CurrentClass))
        return Sema::RTC_Compatible;
    }      
  } else {
    // Any Objective-C pointer type might be acceptable for a protocol
    // method; we just don't know.
    return Sema::RTC_Unknown;
  }
}

return Sema::RTC_Incompatible;
4144}

4146namespace {
4147/// A helper class for searching for methods which a particular method
4148/// overrides.
4149class OverrideSearch {
4150public:
Sema &S;
ObjCMethodDecl *Method;
llvm::SmallSetVector<ObjCMethodDecl*, 4> Overridden;
bool Recursive;

4156public:
OverrideSearch(Sema &S, ObjCMethodDecl *method) : S(S), Method(method) {
  Selector selector = method->getSelector();

  // Bypass this search if we've never seen an instance/class method
  // with this selector before.
  Sema::GlobalMethodPool::iterator it = S.MethodPool.find(selector);
  if (it == S.MethodPool.end()) {
    if (!S.getExternalSource()) return;
    S.ReadMethodPool(selector);
    
    it = S.MethodPool.find(selector);
    if (it == S.MethodPool.end())
      return;
  }
  ObjCMethodList &list =
    method->isInstanceMethod() ? it->second.first : it->second.second;
  if (!list.getMethod()) return;

  ObjCContainerDecl *container
    = cast<ObjCContainerDecl>(method->getDeclContext());

  // Prevent the search from reaching this container again.  This is
  // important with categories, which override methods from the
  // interface and each other.
  if (ObjCCategoryDecl *Category = dyn_cast<ObjCCategoryDecl>(container)) {
    searchFromContainer(container);
    if (ObjCInterfaceDecl *Interface = Category->getClassInterface())
      searchFromContainer(Interface);
  } else {
    searchFromContainer(container);
  }
}

typedef decltype(Overridden)::iterator iterator;
iterator begin() const { return Overridden.begin(); }
iterator end() const { return Overridden.end(); }

4194private:
void searchFromContainer(ObjCContainerDecl *container) {
  if (container->isInvalidDecl()) return;

  switch (container->getDeclKind()) {
4199#define OBJCCONTAINER(type, base) \
  case Decl::type: \
    searchFrom(cast<type##Decl>(container)); \
    break;
4203#define ABSTRACT_DECL(expansion)
4204#define DECL(type, base) \
  case Decl::type:
4206#include "clang/AST/DeclNodes.inc"
    llvm_unreachable("not an ObjC container!")::llvm::llvm_unreachable_internal("not an ObjC container!", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4207);
  }
}

void searchFrom(ObjCProtocolDecl *protocol) {
  if (!protocol->hasDefinition())
    return;
  
  // A method in a protocol declaration overrides declarations from
  // referenced ("parent") protocols.
  search(protocol->getReferencedProtocols());
}

void searchFrom(ObjCCategoryDecl *category) {
  // A method in a category declaration overrides declarations from
  // the main class and from protocols the category references.
  // The main class is handled in the constructor.
  search(category->getReferencedProtocols());
}

void searchFrom(ObjCCategoryImplDecl *impl) {
  // A method in a category definition that has a category
  // declaration overrides declarations from the category
  // declaration.
  if (ObjCCategoryDecl *category = impl->getCategoryDecl()) {
    search(category);
    if (ObjCInterfaceDecl *Interface = category->getClassInterface())
      search(Interface);

  // Otherwise it overrides declarations from the class.
  } else if (ObjCInterfaceDecl *Interface = impl->getClassInterface()) {
    search(Interface);
  }
}

void searchFrom(ObjCInterfaceDecl *iface) {
  // A method in a class declaration overrides declarations from
  if (!iface->hasDefinition())
    return;
  
  //   - categories,
  for (auto *Cat : iface->known_categories())
    search(Cat);

  //   - the super class, and
  if (ObjCInterfaceDecl *super = iface->getSuperClass())
    search(super);

  //   - any referenced protocols.
  search(iface->getReferencedProtocols());
}

void searchFrom(ObjCImplementationDecl *impl) {
  // A method in a class implementation overrides declarations from
  // the class interface.
  if (ObjCInterfaceDecl *Interface = impl->getClassInterface())
    search(Interface);
}

void search(const ObjCProtocolList &protocols) {
  for (ObjCProtocolList::iterator i = protocols.begin(), e = protocols.end();
       i != e; ++i)
    search(*i);
}

void search(ObjCContainerDecl *container) {
  // Check for a method in this container which matches this selector.
  ObjCMethodDecl *meth = container->getMethod(Method->getSelector(),
                                              Method->isInstanceMethod(),
                                              /*AllowHidden=*/true);

  // If we find one, record it and bail out.
  if (meth) {
    Overridden.insert(meth);
    return;
  }

  // Otherwise, search for methods that a hypothetical method here
  // would have overridden.

  // Note that we're now in a recursive case.
  Recursive = true;

  searchFromContainer(container);
}
4292};
4293} // end anonymous namespace

4295void Sema::CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
                                  ObjCInterfaceDecl *CurrentClass,
                                  ResultTypeCompatibilityKind RTC) {
// Search for overridden methods and merge information down from them.
OverrideSearch overrides(*this, ObjCMethod);
// Keep track if the method overrides any method in the class's base classes,
// its protocols, or its categories' protocols; we will keep that info
// in the ObjCMethodDecl.
// For this info, a method in an implementation is not considered as
// overriding the same method in the interface or its categories.
bool hasOverriddenMethodsInBaseOrProtocol = false;
for (OverrideSearch::iterator
       i = overrides.begin(), e = overrides.end(); i != e; ++i) {
  ObjCMethodDecl *overridden = *i;

  if (!hasOverriddenMethodsInBaseOrProtocol) {
    if (isa<ObjCProtocolDecl>(overridden->getDeclContext()) ||
        CurrentClass != overridden->getClassInterface() ||
        overridden->isOverriding()) {
      hasOverriddenMethodsInBaseOrProtocol = true;

    } else if (isa<ObjCImplDecl>(ObjCMethod->getDeclContext())) {
      // OverrideSearch will return as "overridden" the same method in the
      // interface. For hasOverriddenMethodsInBaseOrProtocol, we need to
      // check whether a category of a base class introduced a method with the
      // same selector, after the interface method declaration.
      // To avoid unnecessary lookups in the majority of cases, we use the
      // extra info bits in GlobalMethodPool to check whether there were any
      // category methods with this selector.
      GlobalMethodPool::iterator It =
          MethodPool.find(ObjCMethod->getSelector());
      if (It != MethodPool.end()) {
        ObjCMethodList &List =
          ObjCMethod->isInstanceMethod()? It->second.first: It->second.second;
        unsigned CategCount = List.getBits();
        if (CategCount > 0) {
          // If the method is in a category we'll do lookup if there were at
          // least 2 category methods recorded, otherwise only one will do.
          if (CategCount > 1 ||
              !isa<ObjCCategoryImplDecl>(overridden->getDeclContext())) {
            OverrideSearch overrides(*this, overridden);
            for (OverrideSearch::iterator
                   OI= overrides.begin(), OE= overrides.end(); OI!=OE; ++OI) {
              ObjCMethodDecl *SuperOverridden = *OI;
              if (isa<ObjCProtocolDecl>(SuperOverridden->getDeclContext()) ||
                  CurrentClass != SuperOverridden->getClassInterface()) {
                hasOverriddenMethodsInBaseOrProtocol = true;
                overridden->setOverriding(true);
                break;
              }
            }
          }
        }
      }
    }
  }

  // Propagate down the 'related result type' bit from overridden methods.
  if (RTC != Sema::RTC_Incompatible && overridden->hasRelatedResultType())
    ObjCMethod->SetRelatedResultType();

  // Then merge the declarations.
  mergeObjCMethodDecls(ObjCMethod, overridden);

  if (ObjCMethod->isImplicit() && overridden->isImplicit())
    continue; // Conflicting properties are detected elsewhere.

  // Check for overriding methods
  if (isa<ObjCInterfaceDecl>(ObjCMethod->getDeclContext()) || 
      isa<ObjCImplementationDecl>(ObjCMethod->getDeclContext()))
    CheckConflictingOverridingMethod(ObjCMethod, overridden,
            isa<ObjCProtocolDecl>(overridden->getDeclContext()));
  
  if (CurrentClass && overridden->getDeclContext() != CurrentClass &&
      isa<ObjCInterfaceDecl>(overridden->getDeclContext()) &&
      !overridden->isImplicit() /* not meant for properties */) {
    ObjCMethodDecl::param_iterator ParamI = ObjCMethod->param_begin(),
                                        E = ObjCMethod->param_end();
    ObjCMethodDecl::param_iterator PrevI = overridden->param_begin(),
                                   PrevE = overridden->param_end();
    for (; ParamI != E && PrevI != PrevE; ++ParamI, ++PrevI) {
      assert(PrevI != overridden->param_end() && "Param mismatch")(static_cast <bool> (PrevI != overridden->param_end(
) && "Param mismatch") ? void (0) : __assert_fail ("PrevI != overridden->param_end() && \"Param mismatch\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4376, __extension__ __PRETTY_FUNCTION__));
      QualType T1 = Context.getCanonicalType((*ParamI)->getType());
      QualType T2 = Context.getCanonicalType((*PrevI)->getType());
      // If type of argument of method in this class does not match its
      // respective argument type in the super class method, issue warning;
      if (!Context.typesAreCompatible(T1, T2)) {
        Diag((*ParamI)->getLocation(), diag::ext_typecheck_base_super)
          << T1 << T2;
        Diag(overridden->getLocation(), diag::note_previous_declaration);
        break;
      }
    }
  }
}

ObjCMethod->setOverriding(hasOverriddenMethodsInBaseOrProtocol);
4392}

4394/// Merge type nullability from for a redeclaration of the same entity,
4395/// producing the updated type of the redeclared entity.
4396static QualType mergeTypeNullabilityForRedecl(Sema &S, SourceLocation loc,
                                            QualType type,
                                            bool usesCSKeyword,
                                            SourceLocation prevLoc,
                                            QualType prevType,
                                            bool prevUsesCSKeyword) {
// Determine the nullability of both types.
auto nullability = type->getNullability(S.Context);
auto prevNullability = prevType->getNullability(S.Context);

// Easy case: both have nullability.
if (nullability.hasValue() == prevNullability.hasValue()) {
  // Neither has nullability; continue.
  if (!nullability)
    return type;

  // The nullabilities are equivalent; do nothing.
  if (*nullability == *prevNullability)
    return type;

  // Complain about mismatched nullability.
  S.Diag(loc, diag::err_nullability_conflicting)
    << DiagNullabilityKind(*nullability, usesCSKeyword)
    << DiagNullabilityKind(*prevNullability, prevUsesCSKeyword);
  return type;
}

// If it's the redeclaration that has nullability, don't change anything.
if (nullability)
  return type;

// Otherwise, provide the result with the same nullability.
return S.Context.getAttributedType(
         AttributedType::getNullabilityAttrKind(*prevNullability),
         type, type);
4431}

4433/// Merge information from the declaration of a method in the \@interface
4434/// (or a category/extension) into the corresponding method in the
4435/// @implementation (for a class or category).
4436static void mergeInterfaceMethodToImpl(Sema &S,
                                     ObjCMethodDecl *method,
                                     ObjCMethodDecl *prevMethod) {
// Merge the objc_requires_super attribute.
if (prevMethod->hasAttr<ObjCRequiresSuperAttr>() &&
    !method->hasAttr<ObjCRequiresSuperAttr>()) {
  // merge the attribute into implementation.
  method->addAttr(
    ObjCRequiresSuperAttr::CreateImplicit(S.Context,
                                          method->getLocation()));
}

// Merge nullability of the result type.
QualType newReturnType
  = mergeTypeNullabilityForRedecl(
      S, method->getReturnTypeSourceRange().getBegin(),
      method->getReturnType(),
      method->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability,
      prevMethod->getReturnTypeSourceRange().getBegin(),
      prevMethod->getReturnType(),
      prevMethod->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability);
method->setReturnType(newReturnType);

// Handle each of the parameters.
unsigned numParams = method->param_size();
unsigned numPrevParams = prevMethod->param_size();
for (unsigned i = 0, n = std::min(numParams, numPrevParams); i != n; ++i) {
  ParmVarDecl *param = method->param_begin()[i];
  ParmVarDecl *prevParam = prevMethod->param_begin()[i];

  // Merge nullability.
  QualType newParamType
    = mergeTypeNullabilityForRedecl(
        S, param->getLocation(), param->getType(),
        param->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability,
        prevParam->getLocation(), prevParam->getType(),
        prevParam->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability);
  param->setType(newParamType);
}
4475}

4477/// Verify that the method parameters/return value have types that are supported
4478/// by the x86 target.
4479static void checkObjCMethodX86VectorTypes(Sema &SemaRef,
                                        const ObjCMethodDecl *Method) {
assert(SemaRef.getASTContext().getTargetInfo().getTriple().getArch() ==(static_cast <bool> (SemaRef.getASTContext().getTargetInfo
().getTriple().getArch() == llvm::Triple::x86 && "x86-specific check invoked for a different target"
) ? void (0) : __assert_fail ("SemaRef.getASTContext().getTargetInfo().getTriple().getArch() == llvm::Triple::x86 && \"x86-specific check invoked for a different target\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4483, __extension__ __PRETTY_FUNCTION__))
           llvm::Triple::x86 &&(static_cast <bool> (SemaRef.getASTContext().getTargetInfo
().getTriple().getArch() == llvm::Triple::x86 && "x86-specific check invoked for a different target"
) ? void (0) : __assert_fail ("SemaRef.getASTContext().getTargetInfo().getTriple().getArch() == llvm::Triple::x86 && \"x86-specific check invoked for a different target\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4483, __extension__ __PRETTY_FUNCTION__))
       "x86-specific check invoked for a different target")(static_cast <bool> (SemaRef.getASTContext().getTargetInfo
().getTriple().getArch() == llvm::Triple::x86 && "x86-specific check invoked for a different target"
) ? void (0) : __assert_fail ("SemaRef.getASTContext().getTargetInfo().getTriple().getArch() == llvm::Triple::x86 && \"x86-specific check invoked for a different target\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4483, __extension__ __PRETTY_FUNCTION__));
SourceLocation Loc;
QualType T;
for (const ParmVarDecl *P : Method->parameters()) {
  if (P->getType()->isVectorType()) {
    Loc = P->getLocStart();
    T = P->getType();
    break;
  }
}
if (Loc.isInvalid()) {
  if (Method->getReturnType()->isVectorType()) {
    Loc = Method->getReturnTypeSourceRange().getBegin();
    T = Method->getReturnType();
  } else
    return;
}

// Vector parameters/return values are not supported by objc_msgSend on x86 in
// iOS < 9 and macOS < 10.11.
const auto &Triple = SemaRef.getASTContext().getTargetInfo().getTriple();
VersionTuple AcceptedInVersion;
if (Triple.getOS() == llvm::Triple::IOS)
  AcceptedInVersion = VersionTuple(/*Major=*/9);
else if (Triple.isMacOSX())
  AcceptedInVersion = VersionTuple(/*Major=*/10, /*Minor=*/11);
else
  return;
if (SemaRef.getASTContext().getTargetInfo().getPlatformMinVersion() >=
    AcceptedInVersion)
  return;
SemaRef.Diag(Loc, diag::err_objc_method_unsupported_param_ret_type)
    << T << (Method->getReturnType()->isVectorType() ? /*return value*/ 1
                                                     : /*parameter*/ 0)
    << (Triple.isMacOSX() ? "macOS 10.11" : "iOS 9");
4518}

4520Decl *Sema::ActOnMethodDeclaration(
  Scope *S, SourceLocation MethodLoc, SourceLocation EndLoc,
  tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType,
  ArrayRef<SourceLocation> SelectorLocs, Selector Sel,
  // optional arguments. The number of types/arguments is obtained
  // from the Sel.getNumArgs().
  ObjCArgInfo *ArgInfo, DeclaratorChunk::ParamInfo *CParamInfo,
  unsigned CNumArgs, // c-style args
  const ParsedAttributesView &AttrList, tok::ObjCKeywordKind MethodDeclKind,
  bool isVariadic, bool MethodDefinition) {
// Make sure we can establish a context for the method.
if (!CurContext->isObjCContainer()) {
1
Taking false branch→
  Diag(MethodLoc, diag::err_missing_method_context);
  return nullptr;
}
Decl *ClassDecl = cast<ObjCContainerDecl>(CurContext);
QualType resultDeclType;

bool HasRelatedResultType = false;
TypeSourceInfo *ReturnTInfo = nullptr;
if (ReturnType) {
2
←
Taking true branch→
  resultDeclType = GetTypeFromParser(ReturnType, &ReturnTInfo);

  if (CheckFunctionReturnType(resultDeclType, MethodLoc))
3
←
Assuming the condition is false→
4
←
Taking false branch→
    return nullptr;

  QualType bareResultType = resultDeclType;
  (void)AttributedType::stripOuterNullability(bareResultType);
  HasRelatedResultType = (bareResultType == Context.getObjCInstanceType());
} else { // get the type for "id".
  resultDeclType = Context.getObjCIdType();
  Diag(MethodLoc, diag::warn_missing_method_return_type)
    << FixItHint::CreateInsertion(SelectorLocs.front(), "(id)");
}

ObjCMethodDecl *ObjCMethod = ObjCMethodDecl::Create(
    Context, MethodLoc, EndLoc, Sel, resultDeclType, ReturnTInfo, CurContext,
    MethodType == tok::minus, isVariadic,
5
←
Assuming 'MethodType' is not equal to minus→
    /*isPropertyAccessor=*/false,
    /*isImplicitlyDeclared=*/false, /*isDefined=*/false,
    MethodDeclKind == tok::objc_optional ? ObjCMethodDecl::Optional
6
←
Assuming 'MethodDeclKind' is not equal to objc_optional→
7
←
'?' condition is false→
                                         : ObjCMethodDecl::Required,
    HasRelatedResultType);

SmallVector<ParmVarDecl*, 16> Params;

for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
8
←
Assuming 'i' is equal to 'e'→
9
←
Loop condition is false. Execution continues on line 4619→
  QualType ArgType;
  TypeSourceInfo *DI;

  if (!ArgInfo[i].Type) {
    ArgType = Context.getObjCIdType();
    DI = nullptr;
  } else {
    ArgType = GetTypeFromParser(ArgInfo[i].Type, &DI);
  }

  LookupResult R(*this, ArgInfo[i].Name, ArgInfo[i].NameLoc, 
                 LookupOrdinaryName, forRedeclarationInCurContext());
  LookupName(R, S);
  if (R.isSingleResult()) {
    NamedDecl *PrevDecl = R.getFoundDecl();
    if (S->isDeclScope(PrevDecl)) {
      Diag(ArgInfo[i].NameLoc, 
           (MethodDefinition ? diag::warn_method_param_redefinition 
                             : diag::warn_method_param_declaration)) 
        << ArgInfo[i].Name;
      Diag(PrevDecl->getLocation(), 
           diag::note_previous_declaration);
    }
  }

  SourceLocation StartLoc = DI
    ? DI->getTypeLoc().getBeginLoc()
    : ArgInfo[i].NameLoc;

  ParmVarDecl* Param = CheckParameter(ObjCMethod, StartLoc,
                                      ArgInfo[i].NameLoc, ArgInfo[i].Name,
                                      ArgType, DI, SC_None);

  Param->setObjCMethodScopeInfo(i);

  Param->setObjCDeclQualifier(
    CvtQTToAstBitMask(ArgInfo[i].DeclSpec.getObjCDeclQualifier()));

  // Apply the attributes to the parameter.
  ProcessDeclAttributeList(TUScope, Param, ArgInfo[i].ArgAttrs);
  AddPragmaAttributes(TUScope, Param);

  if (Param->hasAttr<BlocksAttr>()) {
    Diag(Param->getLocation(), diag::err_block_on_nonlocal);
    Param->setInvalidDecl();
  }
  S->AddDecl(Param);
  IdResolver.AddDecl(Param);

  Params.push_back(Param);
}

for (unsigned i = 0, e = CNumArgs; i != e; ++i) {
10
←
Assuming 'i' is equal to 'e'→
11
←
Loop condition is false. Execution continues on line 4632→
  ParmVarDecl *Param = cast<ParmVarDecl>(CParamInfo[i].Param);
  QualType ArgType = Param->getType();
  if (ArgType.isNull())
    ArgType = Context.getObjCIdType();
  else
    // Perform the default array/function conversions (C99 6.7.5.3p[7,8]).
    ArgType = Context.getAdjustedParameterType(ArgType);

  Param->setDeclContext(ObjCMethod);
  Params.push_back(Param);
}

ObjCMethod->setMethodParams(Context, Params, SelectorLocs);
ObjCMethod->setObjCDeclQualifier(
  CvtQTToAstBitMask(ReturnQT.getObjCDeclQualifier()));

ProcessDeclAttributeList(TUScope, ObjCMethod, AttrList);
AddPragmaAttributes(TUScope, ObjCMethod);

// Add the method now.
const ObjCMethodDecl *PrevMethod = nullptr;
if (ObjCImplDecl *ImpDecl = dyn_cast<ObjCImplDecl>(ClassDecl)) {
12
←
Taking false branch→
  if (MethodType == tok::minus) {
    PrevMethod = ImpDecl->getInstanceMethod(Sel);
    ImpDecl->addInstanceMethod(ObjCMethod);
  } else {
    PrevMethod = ImpDecl->getClassMethod(Sel);
    ImpDecl->addClassMethod(ObjCMethod);
  }

  // Merge information from the @interface declaration into the
  // @implementation.
  if (ObjCInterfaceDecl *IDecl = ImpDecl->getClassInterface()) {
    if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
                                        ObjCMethod->isInstanceMethod())) {
      mergeInterfaceMethodToImpl(*this, ObjCMethod, IMD);

      // Warn about defining -dealloc in a category.
      if (isa<ObjCCategoryImplDecl>(ImpDecl) && IMD->isOverriding() &&
          ObjCMethod->getSelector().getMethodFamily() == OMF_dealloc) {
        Diag(ObjCMethod->getLocation(), diag::warn_dealloc_in_category)
          << ObjCMethod->getDeclName();
      }
    }

    // Warn if a method declared in a protocol to which a category or
    // extension conforms is non-escaping and the implementation's method is
    // escaping.
    for (auto *C : IDecl->visible_categories())
      for (auto &P : C->protocols())
        if (auto *IMD = P->lookupMethod(ObjCMethod->getSelector(),
                                        ObjCMethod->isInstanceMethod())) {
          assert(ObjCMethod->parameters().size() ==(static_cast <bool> (ObjCMethod->parameters().size()
 == IMD->parameters().size() && "Methods have different number of parameters"
) ? void (0) : __assert_fail ("ObjCMethod->parameters().size() == IMD->parameters().size() && \"Methods have different number of parameters\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4674, __extension__ __PRETTY_FUNCTION__))
                     IMD->parameters().size() &&(static_cast <bool> (ObjCMethod->parameters().size()
 == IMD->parameters().size() && "Methods have different number of parameters"
) ? void (0) : __assert_fail ("ObjCMethod->parameters().size() == IMD->parameters().size() && \"Methods have different number of parameters\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4674, __extension__ __PRETTY_FUNCTION__))
                 "Methods have different number of parameters")(static_cast <bool> (ObjCMethod->parameters().size()
 == IMD->parameters().size() && "Methods have different number of parameters"
) ? void (0) : __assert_fail ("ObjCMethod->parameters().size() == IMD->parameters().size() && \"Methods have different number of parameters\""
, "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4674, __extension__ __PRETTY_FUNCTION__));
          auto OI = IMD->param_begin(), OE = IMD->param_end();
          auto NI = ObjCMethod->param_begin();
          for (; OI != OE; ++OI, ++NI)
            diagnoseNoescape(*NI, *OI, C, P, *this);
        }
  }
} else {
  cast<DeclContext>(ClassDecl)->addDecl(ObjCMethod);
}

if (PrevMethod) {
13
←
Taking false branch→
  // You can never have two method definitions with the same name.
  Diag(ObjCMethod->getLocation(), diag::err_duplicate_method_decl)
    << ObjCMethod->getDeclName();
  Diag(PrevMethod->getLocation(), diag::note_previous_declaration);
  ObjCMethod->setInvalidDecl();
  return ObjCMethod;
}

// If this Objective-C method does not have a related result type, but we
// are allowed to infer related result types, try to do so based on the
// method family.
ObjCInterfaceDecl *CurrentClass = dyn_cast<ObjCInterfaceDecl>(ClassDecl);
if (!CurrentClass) {
14
←
Taking true branch→
  if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
15
←
Taking false branch→
    CurrentClass = Cat->getClassInterface();
  else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
16
←
Taking false branch→
    CurrentClass = Impl->getClassInterface();
  else if (ObjCCategoryImplDecl *CatImpl
17
←
Taking false branch→
                                 = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
    CurrentClass = CatImpl->getClassInterface();
}

ResultTypeCompatibilityKind RTC
  = CheckRelatedResultTypeCompatibility(*this, ObjCMethod, CurrentClass);

CheckObjCMethodOverrides(ObjCMethod, CurrentClass, RTC);

bool ARCError = false;
if (getLangOpts().ObjCAutoRefCount)
18
←
Assuming the condition is true→
19
←
Taking true branch→
  ARCError = CheckARCMethodDecl(ObjCMethod);
20
←
Calling 'Sema::CheckARCMethodDecl'→

// Infer the related result type when possible.
if (!ARCError && RTC == Sema::RTC_Compatible &&
    !ObjCMethod->hasRelatedResultType() &&
    LangOpts.ObjCInferRelatedResultType) {
  bool InferRelatedResultType = false;
  switch (ObjCMethod->getMethodFamily()) {
  case OMF_None:
  case OMF_copy:
  case OMF_dealloc:
  case OMF_finalize:
  case OMF_mutableCopy:
  case OMF_release:
  case OMF_retainCount:
  case OMF_initialize:
  case OMF_performSelector:
    break;
    
  case OMF_alloc:
  case OMF_new:
      InferRelatedResultType = ObjCMethod->isClassMethod();
    break;
      
  case OMF_init:
  case OMF_autorelease:
  case OMF_retain:
  case OMF_self:
    InferRelatedResultType = ObjCMethod->isInstanceMethod();
    break;
  }
  
  if (InferRelatedResultType &&
      !ObjCMethod->getReturnType()->isObjCIndependentClassType())
    ObjCMethod->SetRelatedResultType();
}

if (MethodDefinition &&
    Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
  checkObjCMethodX86VectorTypes(*this, ObjCMethod);

// + load method cannot have availability attributes. It get called on
// startup, so it has to have the availability of the deployment target.
if (const auto *attr = ObjCMethod->getAttr<AvailabilityAttr>()) {
  if (ObjCMethod->isClassMethod() &&
      ObjCMethod->getSelector().getAsString() == "load") {
    Diag(attr->getLocation(), diag::warn_availability_on_static_initializer)
        << 0;
    ObjCMethod->dropAttr<AvailabilityAttr>();
  }
}

ActOnDocumentableDecl(ObjCMethod);

return ObjCMethod;
4770}

4772bool Sema::CheckObjCDeclScope(Decl *D) {
// Following is also an error. But it is caused by a missing @end
// and diagnostic is issued elsewhere.
if (isa<ObjCContainerDecl>(CurContext->getRedeclContext()))
  return false;

// If we switched context to translation unit while we are still lexically in
// an objc container, it means the parser missed emitting an error.
if (isa<TranslationUnitDecl>(getCurLexicalContext()->getRedeclContext()))
  return false;

Diag(D->getLocation(), diag::err_objc_decls_may_only_appear_in_global_scope);
D->setInvalidDecl();

return true;
4787}

4789/// Called whenever \@defs(ClassName) is encountered in the source.  Inserts the
4790/// instance variables of ClassName into Decls.
4791void Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart,
                   IdentifierInfo *ClassName,
                   SmallVectorImpl<Decl*> &Decls) {
// Check that ClassName is a valid class
ObjCInterfaceDecl *Class = getObjCInterfaceDecl(ClassName, DeclStart);
if (!Class) {
  Diag(DeclStart, diag::err_undef_interface) << ClassName;
  return;
}
if (LangOpts.ObjCRuntime.isNonFragile()) {
  Diag(DeclStart, diag::err_atdef_nonfragile_interface);
  return;
}

// Collect the instance variables
SmallVector<const ObjCIvarDecl*, 32> Ivars;
Context.DeepCollectObjCIvars(Class, true, Ivars);
// For each ivar, create a fresh ObjCAtDefsFieldDecl.
for (unsigned i = 0; i < Ivars.size(); i++) {
  const FieldDecl* ID = Ivars[i];
  RecordDecl *Record = dyn_cast<RecordDecl>(TagD);
  Decl *FD = ObjCAtDefsFieldDecl::Create(Context, Record,
                                         /*FIXME: StartL=*/ID->getLocation(),
                                         ID->getLocation(),
                                         ID->getIdentifier(), ID->getType(),
                                         ID->getBitWidth());
  Decls.push_back(FD);
}

// Introduce all of these fields into the appropriate scope.
for (SmallVectorImpl<Decl*>::iterator D = Decls.begin();
     D != Decls.end(); ++D) {
  FieldDecl *FD = cast<FieldDecl>(*D);
  if (getLangOpts().CPlusPlus)
    PushOnScopeChains(FD, S);
  else if (RecordDecl *Record = dyn_cast<RecordDecl>(TagD))
    Record->addDecl(FD);
}
4829}

4831/// Build a type-check a new Objective-C exception variable declaration.
4832VarDecl *Sema::BuildObjCExceptionDecl(TypeSourceInfo *TInfo, QualType T,
                                    SourceLocation StartLoc,
                                    SourceLocation IdLoc,
                                    IdentifierInfo *Id,
                                    bool Invalid) {
// ISO/IEC TR 18037 S6.7.3: "The type of an object with automatic storage 
// duration shall not be qualified by an address-space qualifier."
// Since all parameters have automatic store duration, they can not have
// an address space.
if (T.getAddressSpace() != LangAS::Default) {
  Diag(IdLoc, diag::err_arg_with_address_space);
  Invalid = true;
}

// An @catch parameter must be an unqualified object pointer type;
// FIXME: Recover from "NSObject foo" by inserting the * in "NSObject *foo"?
if (Invalid) {
  // Don't do any further checking.
} else if (T->isDependentType()) {
  // Okay: we don't know what this type will instantiate to.
} else if (T->isObjCQualifiedIdType()) {
  Invalid = true;
  Diag(IdLoc, diag::err_illegal_qualifiers_on_catch_parm);
} else if (T->isObjCIdType()) {
  // Okay: we don't know what this type will instantiate to.
} else if (!T->isObjCObjectPointerType()) {
  Invalid = true;
  Diag(IdLoc, diag::err_catch_param_not_objc_type);
} else if (!T->getAs<ObjCObjectPointerType>()->getInterfaceType()) {
  Invalid = true;
  Diag(IdLoc, diag::err_catch_param_not_objc_type);
}

VarDecl *New = VarDecl::Create(Context, CurContext, StartLoc, IdLoc, Id,
                               T, TInfo, SC_None);
New->setExceptionVariable(true);

// In ARC, infer 'retaining' for variables of retainable type.
if (getLangOpts().ObjCAutoRefCount && inferObjCARCLifetime(New))
  Invalid = true;

if (Invalid)
  New->setInvalidDecl();
return New;
4876}

4878Decl *Sema::ActOnObjCExceptionDecl(Scope *S, Declarator &D) {
const DeclSpec &DS = D.getDeclSpec();

// We allow the "register" storage class on exception variables because
// GCC did, but we drop it completely. Any other storage class is an error.
if (DS.getStorageClassSpec() == DeclSpec::SCS_register) {
  Diag(DS.getStorageClassSpecLoc(), diag::warn_register_objc_catch_parm)
    << FixItHint::CreateRemoval(SourceRange(DS.getStorageClassSpecLoc()));
} else if (DeclSpec::SCS SCS = DS.getStorageClassSpec()) {
  Diag(DS.getStorageClassSpecLoc(), diag::err_storage_spec_on_catch_parm)
    << DeclSpec::getSpecifierName(SCS);
}
if (DS.isInlineSpecified())
  Diag(DS.getInlineSpecLoc(), diag::err_inline_non_function)
      << getLangOpts().CPlusPlus17;
if (DeclSpec::TSCS TSCS = D.getDeclSpec().getThreadStorageClassSpec())
  Diag(D.getDeclSpec().getThreadStorageClassSpecLoc(),
       diag::err_invalid_thread)
   << DeclSpec::getSpecifierName(TSCS);
D.getMutableDeclSpec().ClearStorageClassSpecs();

DiagnoseFunctionSpecifiers(D.getDeclSpec());

// Check that there are no default arguments inside the type of this
// exception object (C++ only).
if (getLangOpts().CPlusPlus)
  CheckExtraCXXDefaultArguments(D);

TypeSourceInfo *TInfo = GetTypeForDeclarator(D, S);
QualType ExceptionType = TInfo->getType();

VarDecl *New = BuildObjCExceptionDecl(TInfo, ExceptionType,
                                      D.getSourceRange().getBegin(),
                                      D.getIdentifierLoc(),
                                      D.getIdentifier(),
                                      D.isInvalidType());

// Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).
if (D.getCXXScopeSpec().isSet()) {
  Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm)
    << D.getCXXScopeSpec().getRange();
  New->setInvalidDecl();
}

// Add the parameter declaration into this scope.
S->AddDecl(New);
if (D.getIdentifier())
  IdResolver.AddDecl(New);

ProcessDeclAttributes(S, New, D);

if (New->hasAttr<BlocksAttr>())
  Diag(New->getLocation(), diag::err_block_on_nonlocal);
return New;
4932}

4934/// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4935/// initialization.
4936void Sema::CollectIvarsToConstructOrDestruct(ObjCInterfaceDecl *OI,
                              SmallVectorImpl<ObjCIvarDecl*> &Ivars) {
for (ObjCIvarDecl *Iv = OI->all_declared_ivar_begin(); Iv; 
     Iv= Iv->getNextIvar()) {
  QualType QT = Context.getBaseElementType(Iv->getType());
  if (QT->isRecordType())
    Ivars.push_back(Iv);
}
4944}

4946void Sema::DiagnoseUseOfUnimplementedSelectors() {
// Load referenced selectors from the external source.
if (ExternalSource) {
  SmallVector<std::pair<Selector, SourceLocation>, 4> Sels;
  ExternalSource->ReadReferencedSelectors(Sels);
  for (unsigned I = 0, N = Sels.size(); I != N; ++I)
    ReferencedSelectors[Sels[I].first] = Sels[I].second;
}

// Warning will be issued only when selector table is
// generated (which means there is at lease one implementation
// in the TU). This is to match gcc's behavior.
if (ReferencedSelectors.empty() || 
    !Context.AnyObjCImplementation())
  return;
for (auto &SelectorAndLocation : ReferencedSelectors) {
  Selector Sel = SelectorAndLocation.first;
  SourceLocation Loc = SelectorAndLocation.second;
  if (!LookupImplementedMethodInGlobalPool(Sel))
    Diag(Loc, diag::warn_unimplemented_selector) << Sel;
}
4967}

4969ObjCIvarDecl *
4970Sema::GetIvarBackingPropertyAccessor(const ObjCMethodDecl *Method,
                                   const ObjCPropertyDecl *&PDecl) const {
if (Method->isClassMethod())
  return nullptr;
const ObjCInterfaceDecl *IDecl = Method->getClassInterface();
if (!IDecl)
  return nullptr;
Method = IDecl->lookupMethod(Method->getSelector(), /*isInstance=*/true,
                             /*shallowCategoryLookup=*/false,
                             /*followSuper=*/false);
if (!Method || !Method->isPropertyAccessor())
  return nullptr;
if ((PDecl = Method->findPropertyDecl()))
  if (ObjCIvarDecl *IV = PDecl->getPropertyIvarDecl()) {
    // property backing ivar must belong to property's class
    // or be a private ivar in class's implementation.
    // FIXME. fix the const-ness issue.
    IV = const_cast<ObjCInterfaceDecl *>(IDecl)->lookupInstanceVariable(
                                                      IV->getIdentifier());
    return IV;
  }
return nullptr;
4992}

4994namespace {
/// Used by Sema::DiagnoseUnusedBackingIvarInAccessor to check if a property
/// accessor references the backing ivar.
class UnusedBackingIvarChecker :
    public RecursiveASTVisitor<UnusedBackingIvarChecker> {
public:
  Sema &S;
  const ObjCMethodDecl *Method;
  const ObjCIvarDecl *IvarD;
  bool AccessedIvar;
  bool InvokedSelfMethod;

  UnusedBackingIvarChecker(Sema &S, const ObjCMethodDecl *Method,
                           const ObjCIvarDecl *IvarD)
    : S(S), Method(Method), IvarD(IvarD),
      AccessedIvar(false), InvokedSelfMethod(false) {
    assert(IvarD)(static_cast <bool> (IvarD) ? void (0) : __assert_fail (
"IvarD", "/build/llvm-toolchain-snapshot-7~svn338205/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 5010, __extension__ __PRETTY_FUNCTION__));
  }

  bool VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) {
    if (E->getDecl() == IvarD) {
      AccessedIvar = true;
      return false;
    }
    return true;
  }

  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {
    if (E->getReceiverKind() == ObjCMessageExpr::Instance &&
        S.isSelfExpr(E->getInstanceReceiver(), Method)) {
      InvokedSelfMethod = true;
    }
    return true;
  }
};
5029} // end anonymous namespace

5031void Sema::DiagnoseUnusedBackingIvarInAccessor(Scope *S,
                                        const ObjCImplementationDecl *ImplD) {
if (S->hasUnrecoverableErrorOccurred())
  return;

for (const auto *CurMethod : ImplD->instance_methods()) {
  unsigned DIAG = diag::warn_unused_property_backing_ivar;
  SourceLocation Loc = CurMethod->getLocation();
  if (Diags.isIgnored(DIAG, Loc))
    continue;

  const ObjCPropertyDecl *PDecl;
  const ObjCIvarDecl *IV = GetIvarBackingPropertyAccessor(CurMethod, PDecl);
  if (!IV)
    continue;

  UnusedBackingIvarChecker Checker(*this, CurMethod, IV);
  Checker.TraverseStmt(CurMethod->getBody());
  if (Checker.AccessedIvar)
    continue;

  // Do not issue this warning if backing ivar is used somewhere and accessor
  // implementation makes a self call. This is to prevent false positive in
  // cases where the ivar is accessed by another method that the accessor
  // delegates to.
  if (!IV->isReferenced() || !Checker.InvokedSelfMethod) {
    Diag(Loc, DIAG) << IV;
    Diag(PDecl->getLocation(), diag::note_property_declare);
  }
}
5061}

←

/build/llvm-toolchain-snapshot-7~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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~svn338205/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 {
685ParamIdx paramIndex;

687public:
static AllocAlignAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ParamIndex, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AllocAlignAttr(Loc, Ctx, ParamIndex, 0);
  A->setImplicit(true);
  return A;
}

AllocAlignAttr(SourceRange R, ASTContext &Ctx
            , ParamIdx 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;
ParamIdx getParamIndex() const {
  return paramIndex;
}



static bool classof(const Attr *A) { return A->getKind() == attr::AllocAlign; }
714};

716class AllocSizeAttr : public InheritableAttr {
717ParamIdx elemSizeParam;

719ParamIdx numElemsParam;

721public:
static AllocSizeAttr *CreateImplicit(ASTContext &Ctx, ParamIdx ElemSizeParam, ParamIdx NumElemsParam, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AllocSizeAttr(Loc, Ctx, ElemSizeParam, NumElemsParam, 0);
  A->setImplicit(true);
  return A;
}

AllocSizeAttr(SourceRange R, ASTContext &Ctx
            , ParamIdx ElemSizeParam
            , ParamIdx NumElemsParam
            , unsigned SI
           )
  : InheritableAttr(attr::AllocSize, R, SI, false, false)
            , elemSizeParam(ElemSizeParam)
            , numElemsParam(NumElemsParam)
{
}

AllocSizeAttr(SourceRange R, ASTContext &Ctx
            , ParamIdx 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;
ParamIdx getElemSizeParam() const {
  return elemSizeParam;
}

ParamIdx 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~svn338205/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 AnyX86NoCfCheckAttr : public InheritableAttr {
921public:
static AnyX86NoCfCheckAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AnyX86NoCfCheckAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

AnyX86NoCfCheckAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::AnyX86NoCfCheck, R, SI, false, false)
{
}

AnyX86NoCfCheckAttr *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::AnyX86NoCfCheck; }
942};

944class ArcWeakrefUnavailableAttr : public InheritableAttr {
945public:
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; }
966};

968class ArgumentWithTypeTagAttr : public InheritableAttr {
969IdentifierInfo * argumentKind;

971ParamIdx argumentIdx;

973ParamIdx typeTagIdx;

975bool isPointer;

977public:
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, ParamIdx ArgumentIdx, ParamIdx 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, ParamIdx ArgumentIdx, ParamIdx 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
            , ParamIdx ArgumentIdx
            , ParamIdx 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
            , ParamIdx ArgumentIdx
            , ParamIdx 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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1034);
  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;
}

ParamIdx getArgumentIdx() const {
  return argumentIdx;
}

ParamIdx getTypeTagIdx() const {
  return typeTagIdx;
}

bool getIsPointer() const {
  return isPointer;
}



static bool classof(const Attr *A) { return A->getKind() == attr::ArgumentWithTypeTag; }
1062};

1064class ArtificialAttr : public InheritableAttr {
1065public:
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; }
1086};

1088class AsmLabelAttr : public InheritableAttr {
1089unsigned labelLength;
1090char *label;

1092public:
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; }
1130};

1132class AssertCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

1136public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1174);
  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; }
1193};

1195class AssertExclusiveLockAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

1199public:
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; }
1238};

1240class AssertSharedLockAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

1244public:
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; }
1283};

1285class AssumeAlignedAttr : public InheritableAttr {
1286Expr * alignment;

1288Expr * offset;

1290public:
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; }
1333};

1335class AvailabilityAttr : public InheritableAttr {
1336IdentifierInfo * platform;

1338VersionTuple introduced;


1341VersionTuple deprecated;


1344VersionTuple obsoleted;


1347bool unavailable;

1349unsigned messageLength;
1350char *message;

1352bool strict;

1354unsigned replacementLength;
1355char *replacement;

1357public:
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);
}

1454static 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());
1466}
1467static 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);
1478}
1479static 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);
1490} 

static bool classof(const Attr *A) { return A->getKind() == attr::Availability; }
1493};

1495class BlocksAttr : public InheritableAttr {
1496public:
enum BlockType {
  ByRef
};
1500private:
BlockType type;

1503public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1542);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Blocks; }
1547};

1549class C11NoReturnAttr : public InheritableAttr {
1550public:
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; }
1571};

1573class CDeclAttr : public InheritableAttr {
1574public:
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; }
1595};

1597class CFAuditedTransferAttr : public InheritableAttr {
1598public:
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; }
1619};

1621class CFConsumedAttr : public InheritableParamAttr {
1622public:
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; }
1643};

1645class CFReturnsNotRetainedAttr : public InheritableAttr {
1646public:
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; }
1667};

1669class CFReturnsRetainedAttr : public InheritableAttr {
1670public:
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; }
1691};

1693class CFUnknownTransferAttr : public InheritableAttr {
1694public:
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; }
1715};

1717class CPUDispatchAttr : public InheritableAttr {
unsigned cpus_Size;
IdentifierInfo * *cpus_;

1721public:
static CPUDispatchAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CPUDispatchAttr(Loc, Ctx, Cpus, CpusSize, 0);
  A->setImplicit(true);
  return A;
}

CPUDispatchAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * *Cpus, unsigned CpusSize
            , unsigned SI
           )
  : InheritableAttr(attr::CPUDispatch, R, SI, false, false)
            , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size])
{
  std::copy(Cpus, Cpus + cpus_Size, cpus_);
}

CPUDispatchAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CPUDispatch, R, SI, false, false)
            , cpus_Size(0), cpus_(nullptr)
{
}

CPUDispatchAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef IdentifierInfo ** cpus_iterator;
cpus_iterator cpus_begin() const { return cpus_; }
cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
unsigned cpus_size() const { return cpus_Size; }
llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::CPUDispatch; }
1760};

1762class CPUSpecificAttr : public InheritableAttr {
unsigned cpus_Size;
IdentifierInfo * *cpus_;

1766public:
static CPUSpecificAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * *Cpus, unsigned CpusSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CPUSpecificAttr(Loc, Ctx, Cpus, CpusSize, 0);
  A->setImplicit(true);
  return A;
}

CPUSpecificAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * *Cpus, unsigned CpusSize
            , unsigned SI
           )
  : InheritableAttr(attr::CPUSpecific, R, SI, false, false)
            , cpus_Size(CpusSize), cpus_(new (Ctx, 16) IdentifierInfo *[cpus_Size])
{
  std::copy(Cpus, Cpus + cpus_Size, cpus_);
}

CPUSpecificAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::CPUSpecific, R, SI, false, false)
            , cpus_Size(0), cpus_(nullptr)
{
}

CPUSpecificAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef IdentifierInfo ** cpus_iterator;
cpus_iterator cpus_begin() const { return cpus_; }
cpus_iterator cpus_end() const { return cpus_ + cpus_Size; }
unsigned cpus_size() const { return cpus_Size; }
llvm::iterator_range<cpus_iterator> cpus() const { return llvm::make_range(cpus_begin(), cpus_end()); }



  unsigned ActiveArgIndex = 0;

  IdentifierInfo *getCurCPUName() const {
    return *(cpus_begin() + ActiveArgIndex);
  }


static bool classof(const Attr *A) { return A->getKind() == attr::CPUSpecific; }
1811};

1813class CUDAConstantAttr : public InheritableAttr {
1814public:
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; }
1835};

1837class CUDADeviceAttr : public InheritableAttr {
1838public:
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; }
1859};

1861class CUDAGlobalAttr : public InheritableAttr {
1862public:
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; }
1883};

1885class CUDAHostAttr : public InheritableAttr {
1886public:
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; }
1907};

1909class CUDAInvalidTargetAttr : public InheritableAttr {
1910public:
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; }
1931};

1933class CUDALaunchBoundsAttr : public InheritableAttr {
1934Expr * maxThreads;

1936Expr * minBlocks;

1938public:
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; }
1981};

1983class CUDASharedAttr : public InheritableAttr {
1984public:
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; }
2005};

2007class CXX11NoReturnAttr : public InheritableAttr {
2008public:
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; }
2029};

2031class CallableWhenAttr : public InheritableAttr {
2032public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
2038private:
unsigned callableStates_Size;
ConsumedState *callableStates_;

2042public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2097);
}


static bool classof(const Attr *A) { return A->getKind() == attr::CallableWhen; }
2102};

2104class CapabilityAttr : public InheritableAttr {
2105unsigned nameLength;
2106char *name;

2108public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2139);
  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; }
2167};

2169class CapturedRecordAttr : public InheritableAttr {
2170public:
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; }
2191};

2193class CarriesDependencyAttr : public InheritableParamAttr {
2194public:
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; }
2215};

2217class CleanupAttr : public InheritableAttr {
2218FunctionDecl * functionDecl;

2220public:
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; }
2247};

2249class CodeSegAttr : public InheritableAttr {
2250unsigned nameLength;
2251char *name;

2253public:
static CodeSegAttr *CreateImplicit(ASTContext &Ctx, llvm::StringRef Name, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CodeSegAttr(Loc, Ctx, Name, 0);
  A->setImplicit(true);
  return A;
}

CodeSegAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef Name
            , unsigned SI
           )
  : InheritableAttr(attr::CodeSeg, R, SI, false, false)
            , nameLength(Name.size()),name(new (Ctx, 1) char[nameLength])
{
    if (!Name.empty())
      std::memcpy(name, Name.data(), nameLength);
}

CodeSegAttr *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::CodeSeg; }
2291};

2293class ColdAttr : public InheritableAttr {
2294public:
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; }
2315};

2317class CommonAttr : public InheritableAttr {
2318public:
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; }
2339};

2341class ConstAttr : public InheritableAttr {
2342public:
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; }
2363};

2365class ConstructorAttr : public InheritableAttr {
2366int priority;

2368public:
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; }
2405};

2407class ConsumableAttr : public InheritableAttr {
2408public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
2414private:
ConsumedState defaultState;

2417public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2460);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Consumable; }
2465};

2467class ConsumableAutoCastAttr : public InheritableAttr {
2468public:
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; }
2489};

2491class ConsumableSetOnReadAttr : public InheritableAttr {
2492public:
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; }
2513};

2515class ConvergentAttr : public InheritableAttr {
2516public:
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; }
2537};

2539class DLLExportAttr : public InheritableAttr {
2540public:
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; }
2561};

2563class DLLImportAttr : public InheritableAttr {
2564public:
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;

2583private:
bool PropagatedToBaseTemplate = false;

2586public:
void setPropagatedToBaseTemplate() { PropagatedToBaseTemplate = true; }
bool wasPropagatedToBaseTemplate() { return PropagatedToBaseTemplate; }


static bool classof(const Attr *A) { return A->getKind() == attr::DLLImport; }
2592};

2594class DeprecatedAttr : public InheritableAttr {
2595unsigned messageLength;
2596char *message;

2598unsigned replacementLength;
2599char *replacement;

2601public:
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; }
2665};

2667class DestructorAttr : public InheritableAttr {
2668int priority;

2670public:
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; }
2707};

2709class DiagnoseIfAttr : public InheritableAttr {
2710Expr * cond;

2712unsigned messageLength;
2713char *message;

2715public:
enum DiagnosticType {
  DT_Error,
  DT_Warning
};
2720private:
DiagnosticType diagnosticType;

2723bool argDependent;

2725NamedDecl * parent;

2727public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2818);
}
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; }
2834};

2836class DisableTailCallsAttr : public InheritableAttr {
2837public:
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; }
2858};

2860class EmptyBasesAttr : public InheritableAttr {
2861public:
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; }
2882};

2884class EnableIfAttr : public InheritableAttr {
2885Expr * cond;

2887unsigned messageLength;
2888char *message;

2890public:
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; }
2934};

2936class EnumExtensibilityAttr : public InheritableAttr {
2937public:
enum Kind {
  Closed,
  Open
};
2942private:
Kind extensibility;

2945public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2986);
}


static bool classof(const Attr *A) { return A->getKind() == attr::EnumExtensibility; }
2991};

2993class ExclusiveTrylockFunctionAttr : public InheritableAttr {
2994Expr * successValue;

unsigned args_Size;
Expr * *args_;

2999public:
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; }
3046};

3048class ExternalSourceSymbolAttr : public InheritableAttr {
3049unsigned languageLength;
3050char *language;

3052unsigned definedInLength;
3053char *definedIn;

3055bool generatedDeclaration;

3057public:
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; }
3128};

3130class FallThroughAttr : public StmtAttr {
3131public:
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; }
3152};

3154class FastCallAttr : public InheritableAttr {
3155public:
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; }
3176};

3178class FinalAttr : public InheritableAttr {
3179public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3204);
  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; }
3213};

3215class FlagEnumAttr : public InheritableAttr {
3216public:
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; }
3237};

3239class FlattenAttr : public InheritableAttr {
3240public:
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; }
3261};

3263class FormatAttr : public InheritableAttr {
3264IdentifierInfo * type;

3266int formatIdx;

3268int firstArg;

3270public:
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; }
3309};

3311class FormatArgAttr : public InheritableAttr {
3312ParamIdx formatIdx;

3314public:
static FormatArgAttr *CreateImplicit(ASTContext &Ctx, ParamIdx FormatIdx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) FormatArgAttr(Loc, Ctx, FormatIdx, 0);
  A->setImplicit(true);
  return A;
}

FormatArgAttr(SourceRange R, ASTContext &Ctx
            , ParamIdx 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;
ParamIdx getFormatIdx() const {
  return formatIdx;
}



static bool classof(const Attr *A) { return A->getKind() == attr::FormatArg; }
3341};

3343class GNUInlineAttr : public InheritableAttr {
3344public:
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; }
3365};

3367class GuardedByAttr : public InheritableAttr {
3368Expr * arg;

3370public:
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; }
3397};

3399class GuardedVarAttr : public InheritableAttr {
3400public:
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; }
3421};

3423class HotAttr : public InheritableAttr {
3424public:
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; }
3445};

3447class IBActionAttr : public InheritableAttr {
3448public:
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; }
3469};

3471class IBOutletAttr : public InheritableAttr {
3472public:
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; }
3493};

3495class IBOutletCollectionAttr : public InheritableAttr {
3496TypeSourceInfo * interface_;

3498public:
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; }
3535};

3537class IFuncAttr : public Attr {
3538unsigned resolverLength;
3539char *resolver;

3541public:
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; }
3579};

3581class InitPriorityAttr : public InheritableAttr {
3582unsigned priority;

3584public:
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; }
3611};

3613class InitSegAttr : public Attr {
3614unsigned sectionLength;
3615char *section;

3617public:
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; }
3659};

3661class IntelOclBiccAttr : public InheritableAttr {
3662public:
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; }
3683};

3685class InternalLinkageAttr : public InheritableAttr {
3686public:
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; }
3707};

3709class LTOVisibilityPublicAttr : public InheritableAttr {
3710public:
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; }
3731};

3733class LayoutVersionAttr : public InheritableAttr {
3734unsigned version;

3736public:
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; }
3763};

3765class LockReturnedAttr : public InheritableAttr {
3766Expr * arg;

3768public:
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; }
3795};

3797class LocksExcludedAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

3801public:
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; }
3840};

3842class LoopHintAttr : public Attr {
3843public:
enum OptionType {
  Vectorize,
  VectorizeWidth,
  Interleave,
  InterleaveCount,
  Unroll,
  UnrollCount,
  Distribute
};
3853private:
OptionType option;

3856public:
enum LoopHintState {
  Enable,
  Disable,
  Numeric,
  AssumeSafety,
  Full
};
3864private:
LoopHintState state;

3867Expr * value;

3869public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3901);
  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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3938);
}
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3967);
}
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3984);
}

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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3998, __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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4030, __extension__ __PRETTY_FUNCTION__));
  return getOptionName(option) + getValueString(Policy);
}


static bool classof(const Attr *A) { return A->getKind() == attr::LoopHint; }
4036};

4038class MSABIAttr : public InheritableAttr {
4039public:
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; }
4060};

4062class MSInheritanceAttr : public InheritableAttr {
4063bool bestCase;

4065public:
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;
}

static MSInheritanceAttr *CreateImplicit(ASTContext &Ctx, Spelling S, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MSInheritanceAttr(Loc, Ctx, 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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4108);
  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; }
4145};

4147class MSNoVTableAttr : public InheritableAttr {
4148public:
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; }
4169};

4171class MSP430InterruptAttr : public InheritableAttr {
4172unsigned number;

4174public:
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; }
4201};

4203class MSStructAttr : public InheritableAttr {
4204public:
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; }
4225};

4227class MSVtorDispAttr : public InheritableAttr {
4228unsigned vdm;

4230public:
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; }
4265};

4267class MaxFieldAlignmentAttr : public InheritableAttr {
4268unsigned alignment;

4270public:
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; }
4297};

4299class MayAliasAttr : public InheritableAttr {
4300public:
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; }
4321};

4323class MicroMipsAttr : public InheritableAttr {
4324public:
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; }
4345};

4347class MinSizeAttr : public InheritableAttr {
4348public:
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; }
4369};

4371class MinVectorWidthAttr : public InheritableAttr {
4372unsigned vectorWidth;

4374public:
static MinVectorWidthAttr *CreateImplicit(ASTContext &Ctx, unsigned VectorWidth, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) MinVectorWidthAttr(Loc, Ctx, VectorWidth, 0);
  A->setImplicit(true);
  return A;
}

MinVectorWidthAttr(SourceRange R, ASTContext &Ctx
            , unsigned VectorWidth
            , unsigned SI
           )
  : InheritableAttr(attr::MinVectorWidth, R, SI, false, false)
            , vectorWidth(VectorWidth)
{
}

MinVectorWidthAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
unsigned getVectorWidth() const {
  return vectorWidth;
}



static bool classof(const Attr *A) { return A->getKind() == attr::MinVectorWidth; }
4401};

4403class Mips16Attr : public InheritableAttr {
4404public:
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; }
4425};

4427class MipsInterruptAttr : public InheritableAttr {
4428public:
enum InterruptType {
  sw0,
  sw1,
  hw0,
  hw1,
  hw2,
  hw3,
  hw4,
  hw5,
  eic
};
4440private:
InterruptType interrupt;

4443public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4499);
}


static bool classof(const Attr *A) { return A->getKind() == attr::MipsInterrupt; }
4504};

4506class MipsLongCallAttr : public InheritableAttr {
4507public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4534);
  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; }
4544};

4546class MipsShortCallAttr : public InheritableAttr {
4547public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4574);
  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; }
4584};

4586class ModeAttr : public Attr {
4587IdentifierInfo * mode;

4589public:
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; }
4616};

4618class NSConsumedAttr : public InheritableParamAttr {
4619public:
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; }
4640};

4642class NSConsumesSelfAttr : public InheritableAttr {
4643public:
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; }
4664};

4666class NSReturnsAutoreleasedAttr : public InheritableAttr {
4667public:
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; }
4688};

4690class NSReturnsNotRetainedAttr : public InheritableAttr {
4691public:
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; }
4712};

4714class NSReturnsRetainedAttr : public InheritableAttr {
4715public:
static NSReturnsRetainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NSReturnsRetainedAttr(Loc, Ctx, 0);
25
←
'A' initialized to a null pointer value→
  A->setImplicit(true);
26
←
Called C++ object pointer is null
  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; }
4736};

4738class NakedAttr : public InheritableAttr {
4739public:
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; }
4760};

4762class NoAliasAttr : public InheritableAttr {
4763public:
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; }
4784};

4786class NoCommonAttr : public InheritableAttr {
4787public:
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; }
4808};

4810class NoDebugAttr : public InheritableAttr {
4811public:
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; }
4832};

4834class NoDuplicateAttr : public InheritableAttr {
4835public:
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; }
4856};

4858class NoEscapeAttr : public Attr {
4859public:
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; }
4880};

4882class NoInlineAttr : public InheritableAttr {
4883public:
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; }
4904};

4906class NoInstrumentFunctionAttr : public InheritableAttr {
4907public:
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; }
4928};

4930class NoMicroMipsAttr : public InheritableAttr {
4931public:
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; }
4952};

4954class NoMips16Attr : public InheritableAttr {
4955public:
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; }
4976};

4978class NoReturnAttr : public InheritableAttr {
4979public:
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; }
5000};

5002class NoSanitizeAttr : public InheritableAttr {
unsigned sanitizers_Size;
StringRef *sanitizers_;

5006public:
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; }
5063};

5065class NoSplitStackAttr : public InheritableAttr {
5066public:
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; }
5087};

5089class NoStackProtectorAttr : public InheritableAttr {
5090public:
static NoStackProtectorAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoStackProtectorAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoStackProtectorAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::NoStackProtector, R, SI, false, false)
{
}

NoStackProtectorAttr *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::NoStackProtector; }
5111};

5113class NoThreadSafetyAnalysisAttr : public InheritableAttr {
5114public:
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; }
5135};

5137class NoThrowAttr : public InheritableAttr {
5138public:
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; }
5159};

5161class NonNullAttr : public InheritableParamAttr {
unsigned args_Size;
ParamIdx *args_;

5165public:
static NonNullAttr *CreateImplicit(ASTContext &Ctx, ParamIdx *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
            , ParamIdx *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableParamAttr(attr::NonNull, R, SI, false, true)
            , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[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 ParamIdx* 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()); }



  bool isNonNull(unsigned IdxAST) const {
    if (!args_size())
      return true;
    return args_end() != std::find_if(
        args_begin(), args_end(),
        [=](const ParamIdx &Idx) { return Idx.getASTIndex() == IdxAST; });
  }


static bool classof(const Attr *A) { return A->getKind() == attr::NonNull; }
5212};

5214class NotTailCalledAttr : public InheritableAttr {
5215public:
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; }
5236};

5238class OMPCaptureKindAttr : public Attr {
5239unsigned captureKind;

5241public:
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; }
5268};

5270class OMPCaptureNoInitAttr : public InheritableAttr {
5271public:
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; }
5292};

5294class OMPDeclareSimdDeclAttr : public Attr {
5295public:
enum BranchStateTy {
  BS_Undefined,
  BS_Inbranch,
  BS_Notinbranch
};
5301private:
BranchStateTy branchState;

5304Expr * 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_;

5324public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5404);
}
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; }
5504};

5506class OMPDeclareTargetDeclAttr : public Attr {
5507public:
enum MapTypeTy {
  MT_To,
  MT_Link
};
5512private:
MapTypeTy mapType;

5515public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5556);
}

  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; }
5567};

5569class OMPReferencedVarAttr : public Attr {
5570Expr * ref;

5572public:
static OMPReferencedVarAttr *CreateImplicit(ASTContext &Ctx, Expr * Ref, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPReferencedVarAttr(Loc, Ctx, Ref, 0);
  A->setImplicit(true);
  return A;
}

OMPReferencedVarAttr(SourceRange R, ASTContext &Ctx
            , Expr * Ref
            , unsigned SI
           )
  : Attr(attr::OMPReferencedVar, R, SI, false)
            , ref(Ref)
{
}

OMPReferencedVarAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
Expr * getRef() const {
  return ref;
}



static bool classof(const Attr *A) { return A->getKind() == attr::OMPReferencedVar; }
5599};

5601class OMPThreadPrivateDeclAttr : public InheritableAttr {
5602public:
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; }
5623};

5625class ObjCBoxableAttr : public Attr {
5626public:
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; }
5647};

5649class ObjCBridgeAttr : public InheritableAttr {
5650IdentifierInfo * bridgedType;

5652public:
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; }
5679};

5681class ObjCBridgeMutableAttr : public InheritableAttr {
5682IdentifierInfo * bridgedType;

5684public:
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; }
5711};

5713class ObjCBridgeRelatedAttr : public InheritableAttr {
5714IdentifierInfo * relatedClass;

5716IdentifierInfo * classMethod;

5718IdentifierInfo * instanceMethod;

5720public:
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 *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; }
5759};

5761class ObjCDesignatedInitializerAttr : public Attr {
5762public:
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; }
5783};

5785class ObjCExceptionAttr : public InheritableAttr {
5786public:
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; }
5807};

5809class ObjCExplicitProtocolImplAttr : public InheritableAttr {
5810public:
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; }
5831};

5833class ObjCIndependentClassAttr : public InheritableAttr {
5834public:
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; }
5855};

5857class ObjCMethodFamilyAttr : public InheritableAttr {
5858public:
enum FamilyKind {
  OMF_None,
  OMF_alloc,
  OMF_copy,
  OMF_init,
  OMF_mutableCopy,
  OMF_new
};
5867private:
FamilyKind family;

5870public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5919);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ObjCMethodFamily; }
5924};

5926class ObjCNSObjectAttr : public InheritableAttr {
5927public:
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; }
5948};

5950class ObjCPreciseLifetimeAttr : public InheritableAttr {
5951public:
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; }
5972};

5974class ObjCRequiresPropertyDefsAttr : public InheritableAttr {
5975public:
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; }
5996};

5998class ObjCRequiresSuperAttr : public InheritableAttr {
5999public:
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; }
6020};

6022class ObjCReturnsInnerPointerAttr : public InheritableAttr {
6023public:
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; }
6044};

6046class ObjCRootClassAttr : public InheritableAttr {
6047public:
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; }
6068};

6070class ObjCRuntimeNameAttr : public Attr {
6071unsigned metadataNameLength;
6072char *metadataName;

6074public:
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; }
6112};

6114class ObjCRuntimeVisibleAttr : public Attr {
6115public:
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; }
6136};

6138class ObjCSubclassingRestrictedAttr : public InheritableAttr {
6139public:
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; }
6160};

6162class OpenCLAccessAttr : public Attr {
6163public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6189);
  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; }
6207};

6209class OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
6210unsigned subGroupSize;

6212public:
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; }
6239};

6241class OpenCLKernelAttr : public InheritableAttr {
6242public:
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; }
6263};

6265class OpenCLUnrollHintAttr : public InheritableAttr {
6266unsigned unrollHint;

6268public:
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; }
6295};

6297class OptimizeNoneAttr : public InheritableAttr {
6298public:
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; }
6319};

6321class OverloadableAttr : public Attr {
6322public:
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; }
6343};

6345class OverrideAttr : public InheritableAttr {
6346public:
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; }
6367};

6369class OwnershipAttr : public InheritableAttr {
6370IdentifierInfo * module;

unsigned args_Size;
ParamIdx *args_;

6375public:
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, ParamIdx *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
            , ParamIdx *Args, unsigned ArgsSize
            , unsigned SI
           )
  : InheritableAttr(attr::Ownership, R, SI, false, false)
            , module(Module)
            , args_Size(ArgsSize), args_(new (Ctx, 16) ParamIdx[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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6422);
  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 ParamIdx* 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; }
6464};

6466class PackedAttr : public InheritableAttr {
6467public:
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; }
6488};

6490class ParamTypestateAttr : public InheritableAttr {
6491public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
6497private:
ConsumedState paramState;

6500public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6543);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ParamTypestate; }
6548};

6550class PascalAttr : public InheritableAttr {
6551public:
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; }
6572};

6574class PassObjectSizeAttr : public InheritableParamAttr {
6575int type;

6577public:
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; }
6604};

6606class PcsAttr : public InheritableAttr {
6607public:
enum PCSType {
  AAPCS,
  AAPCS_VFP
};
6612private:
PCSType pCS;

6615public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6656);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Pcs; }
6661};

6663class PragmaClangBSSSectionAttr : public InheritableAttr {
6664unsigned nameLength;
6665char *name;

6667public:
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; }
6705};

6707class PragmaClangDataSectionAttr : public InheritableAttr {
6708unsigned nameLength;
6709char *name;

6711public:
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; }
6749};

6751class PragmaClangRodataSectionAttr : public InheritableAttr {
6752unsigned nameLength;
6753char *name;

6755public:
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; }
6793};

6795class PragmaClangTextSectionAttr : public InheritableAttr {
6796unsigned nameLength;
6797char *name;

6799public:
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; }
6837};

6839class PreserveAllAttr : public InheritableAttr {
6840public:
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; }
6861};

6863class PreserveMostAttr : public InheritableAttr {
6864public:
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; }
6885};

6887class PtGuardedByAttr : public InheritableAttr {
6888Expr * arg;

6890public:
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; }
6917};

6919class PtGuardedVarAttr : public InheritableAttr {
6920public:
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; }
6941};

6943class PureAttr : public InheritableAttr {
6944public:
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; }
6965};

6967class RISCVInterruptAttr : public InheritableAttr {
6968public:
enum InterruptType {
  user,
  supervisor,
  machine
};
6974private:
InterruptType interrupt;

6977public:
static RISCVInterruptAttr *CreateImplicit(ASTContext &Ctx, InterruptType Interrupt, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) RISCVInterruptAttr(Loc, Ctx, Interrupt, 0);
  A->setImplicit(true);
  return A;
}

RISCVInterruptAttr(SourceRange R, ASTContext &Ctx
            , InterruptType Interrupt
            , unsigned SI
           )
  : InheritableAttr(attr::RISCVInterrupt, R, SI, false, false)
            , interrupt(Interrupt)
{
}

RISCVInterruptAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::RISCVInterrupt, R, SI, false, false)
            , interrupt(InterruptType(0))
{
}

RISCVInterruptAttr *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("user", RISCVInterruptAttr::user)
    .Case("supervisor", RISCVInterruptAttr::supervisor)
    .Case("machine", RISCVInterruptAttr::machine)
    .Default(Optional<InterruptType>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertInterruptTypeToStr(InterruptType Val) {
  switch(Val) {
  case RISCVInterruptAttr::user: return "user";
  case RISCVInterruptAttr::supervisor: return "supervisor";
  case RISCVInterruptAttr::machine: return "machine";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-7~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7028);
}


static bool classof(const Attr *A) { return A->getKind() == attr::RISCVInterrupt; }
7033};

7035class RegCallAttr : public InheritableAttr {
7036public:
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; }
7057};

7059class ReleaseCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

7063public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7105);
  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; }
7132};

7134class RenderScriptKernelAttr : public Attr {
7135public:
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; }
7156};

7158class ReqdWorkGroupSizeAttr : public InheritableAttr {
7159unsigned xDim;

7161unsigned yDim;

7163unsigned zDim;

7165public:
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; }
7204};

7206class RequireConstantInitAttr : public InheritableAttr {
7207public:
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; }
7228};

7230class RequiresCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

7234public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7276);
  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; }
7301};

7303class RestrictAttr : public InheritableAttr {
7304public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7330);
  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; }
7339};

7341class ReturnTypestateAttr : public InheritableAttr {
7342public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
7348private:
ConsumedState state;

7351public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7394);
}


static bool classof(const Attr *A) { return A->getKind() == attr::ReturnTypestate; }
7399};

7401class ReturnsNonNullAttr : public InheritableAttr {
7402public:
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; }
7423};

7425class ReturnsTwiceAttr : public InheritableAttr {
7426public:
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; }
7447};

7449class ScopedLockableAttr : public InheritableAttr {
7450public:
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; }
7471};

7473class SectionAttr : public InheritableAttr {
7474unsigned nameLength;
7475char *name;

7477public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7507);
  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; }
7529};

7531class SelectAnyAttr : public InheritableAttr {
7532public:
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; }
7553};

7555class SentinelAttr : public InheritableAttr {
7556int sentinel;

7558int nullPos;

7560public:
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; }
7606};

7608class SetTypestateAttr : public InheritableAttr {
7609public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
7615private:
ConsumedState newState;

7618public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7661);
}


static bool classof(const Attr *A) { return A->getKind() == attr::SetTypestate; }
7666};

7668class SharedTrylockFunctionAttr : public InheritableAttr {
7669Expr * successValue;

unsigned args_Size;
Expr * *args_;

7674public:
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; }
7721};

7723class StdCallAttr : public InheritableAttr {
7724public:
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; }
7745};

7747class SuppressAttr : public StmtAttr {
unsigned diagnosticIdentifiers_Size;
StringRef *diagnosticIdentifiers_;

7751public:
static SuppressAttr *CreateImplicit(ASTContext &Ctx, StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SuppressAttr(Loc, Ctx, DiagnosticIdentifiers, DiagnosticIdentifiersSize, 0);
  A->setImplicit(true);
  return A;
}

SuppressAttr(SourceRange R, ASTContext &Ctx
            , StringRef *DiagnosticIdentifiers, unsigned DiagnosticIdentifiersSize
            , unsigned SI
           )
  : StmtAttr(attr::Suppress, R, SI, false)
            , diagnosticIdentifiers_Size(DiagnosticIdentifiersSize), diagnosticIdentifiers_(new (Ctx, 16) StringRef[diagnosticIdentifiers_Size])
{
  for (size_t I = 0, E = diagnosticIdentifiers_Size; I != E;
       ++I) {
    StringRef Ref = DiagnosticIdentifiers[I];
    if (!Ref.empty()) {
      char *Mem = new (Ctx, 1) char[Ref.size()];
      std::memcpy(Mem, Ref.data(), Ref.size());
      diagnosticIdentifiers_[I] = StringRef(Mem, Ref.size());
    }
  }
}

SuppressAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : StmtAttr(attr::Suppress, R, SI, false)
            , diagnosticIdentifiers_Size(0), diagnosticIdentifiers_(nullptr)
{
}

SuppressAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef StringRef* diagnosticIdentifiers_iterator;
diagnosticIdentifiers_iterator diagnosticIdentifiers_begin() const { return diagnosticIdentifiers_; }
diagnosticIdentifiers_iterator diagnosticIdentifiers_end() const { return diagnosticIdentifiers_ + diagnosticIdentifiers_Size; }
unsigned diagnosticIdentifiers_size() const { return diagnosticIdentifiers_Size; }
llvm::iterator_range<diagnosticIdentifiers_iterator> diagnosticIdentifiers() const { return llvm::make_range(diagnosticIdentifiers_begin(), diagnosticIdentifiers_end()); }




static bool classof(const Attr *A) { return A->getKind() == attr::Suppress; }
7798};

7800class SwiftCallAttr : public InheritableAttr {
7801public:
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; }
7822};

7824class SwiftContextAttr : public ParameterABIAttr {
7825public:
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; }
7846};

7848class SwiftErrorResultAttr : public ParameterABIAttr {
7849public:
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; }
7870};

7872class SwiftIndirectResultAttr : public ParameterABIAttr {
7873public:
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; }
7894};

7896class SysVABIAttr : public InheritableAttr {
7897public:
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; }
7918};

7920class TLSModelAttr : public InheritableAttr {
7921unsigned modelLength;
7922char *model;

7924public:
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; }
7962};

7964class TargetAttr : public InheritableAttr {
7965unsigned featuresStrLength;
7966char *featuresStr;

7968public:
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();
    llvm::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; }
8062};

8064class TestTypestateAttr : public InheritableAttr {
8065public:
enum ConsumedState {
  Consumed,
  Unconsumed
};
8070private:
ConsumedState testState;

8073public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8114);
}


static bool classof(const Attr *A) { return A->getKind() == attr::TestTypestate; }
8119};

8121class ThisCallAttr : public InheritableAttr {
8122public:
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; }
8143};

8145class ThreadAttr : public Attr {
8146public:
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; }
8167};

8169class TransparentUnionAttr : public InheritableAttr {
8170public:
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; }
8191};

8193class TrivialABIAttr : public InheritableAttr {
8194public:
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; }
8215};

8217class TryAcquireCapabilityAttr : public InheritableAttr {
8218Expr * successValue;

unsigned args_Size;
Expr * *args_;

8223public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8265);
  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; }
8288};

8290class TypeTagForDatatypeAttr : public InheritableAttr {
8291IdentifierInfo * argumentKind;

8293TypeSourceInfo * matchingCType;

8295bool layoutCompatible;

8297bool mustBeNull;

8299public:
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; }
8346};

8348class TypeVisibilityAttr : public InheritableAttr {
8349public:
enum VisibilityType {
  Default,
  Hidden,
  Protected
};
8355private:
VisibilityType visibility;

8358public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8402);
}


static bool classof(const Attr *A) { return A->getKind() == attr::TypeVisibility; }
8407};

8409class UnavailableAttr : public InheritableAttr {
8410unsigned messageLength;
8411char *message;

8413public:
enum ImplicitReason {
  IR_None,
  IR_ARCForbiddenType,
  IR_ForbiddenWeak,
  IR_ARCForbiddenConversion,
  IR_ARCInitReturnsUnrelated,
  IR_ARCFieldWithOwnership
};
8422private:
ImplicitReason implicitReason;

8425public:
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; }
8496};

8498class UnusedAttr : public InheritableAttr {
8499public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8526);
  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; }
8536};

8538class UsedAttr : public InheritableAttr {
8539public:
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; }
8560};

8562class UuidAttr : public InheritableAttr {
8563unsigned guidLength;
8564char *guid;

8566public:
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; }
8604};

8606class VecReturnAttr : public InheritableAttr {
8607public:
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; }
8628};

8630class VecTypeHintAttr : public InheritableAttr {
8631TypeSourceInfo * typeHint;

8633public:
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; }
8662};

8664class VectorCallAttr : public InheritableAttr {
8665public:
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; }
8686};

8688class VisibilityAttr : public InheritableAttr {
8689public:
enum VisibilityType {
  Default,
  Hidden,
  Protected
};
8695private:
VisibilityType visibility;

8698public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8742);
}


static bool classof(const Attr *A) { return A->getKind() == attr::Visibility; }
8747};

8749class WarnUnusedAttr : public InheritableAttr {
8750public:
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; }
8771};

8773class WarnUnusedResultAttr : public InheritableAttr {
8774public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8802);
  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; }
8813};

8815class WeakAttr : public InheritableAttr {
8816public:
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; }
8837};

8839class WeakImportAttr : public InheritableAttr {
8840public:
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; }
8861};

8863class WeakRefAttr : public InheritableAttr {
8864unsigned aliaseeLength;
8865char *aliasee;

8867public:
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; }
8913};

8915class WorkGroupSizeHintAttr : public InheritableAttr {
8916unsigned xDim;

8918unsigned yDim;

8920unsigned zDim;

8922public:
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; }
8961};

8963class X86ForceAlignArgPointerAttr : public InheritableAttr {
8964public:
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; }
8985};

8987class XRayInstrumentAttr : public InheritableAttr {
8988public:
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~svn338205/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9017);
  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; }
9035};

9037class XRayLogArgsAttr : public InheritableAttr {
9038unsigned argumentCount;

9040public:
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; }
9067};

9069#endif // LLVM_CLANG_ATTR_CLASSES_INC