/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc

Bug Summary

File:	build-llvm/tools/clang/include/clang/AST/Attrs.inc
Warning:	line 6798, 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-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 -analyzer-config-compatibility-mode=true -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-9/lib/clang/9.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/include -I /build/llvm-toolchain-snapshot-9~svn362543/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/9.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-9/lib/clang/9.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-9~svn362543=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -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-2019-06-05-060531-1271-1 -x c++ /build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp -faddrsig

/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp

→

1//===--- SemaDeclObjC.cpp - Semantic Analysis for ObjC Declarations -------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9//  This file implements semantic analysis for Objective C declarations.
10//
11//===----------------------------------------------------------------------===//

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

30using namespace clang;

32/// Check whether the given method, which must be in the 'init'
33/// family, is a valid member of that family.
34///
35/// \param receiverTypeIfCall - if null, check this as if declaring it;
36///   if non-null, check this as if making a call to it with the given
37///   receiver type
38///
39/// \return true to indicate that there was an error and appropriate
40///   actions were taken
41bool 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!")((resultClass && "unexpected object type!") ? static_cast
<void> (0) : __assert_fail ("resultClass && \"unexpected object type!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 60, __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!")((receiverClass && "method not associated with a class!"
) ? static_cast<void> (0) : __assert_fail ("receiverClass && \"method not associated with a class!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 85, __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;
109}

111/// Issue a warning if the parameter of the overridden method is non-escaping
112/// but the parameter of the overriding method is not.
113static 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;
122}

124/// Produce additional diagnostics if a category conforms to a protocol that
125/// defines a method taking a non-escaping parameter.
126static 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());
133}

135void 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);
}
220}

222/// Check a method declaration for compatibility with the Objective-C
223/// ARC conventions.
224bool Sema::CheckARCMethodDecl(ObjCMethodDecl *method) {
ObjCMethodFamily family = method->getMethodFamily();
switch (family) {
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>() ||
      method->hasAttr<NSReturnsNotRetainedAttr>() ||
      method->hasAttr<NSReturnsAutoreleasedAttr>())
    return false;
  break;
}

method->addAttr(NSReturnsRetainedAttr::CreateImplicit(Context));
return false;
279}

281static 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");
324}

326/// AddAnyMethodToGlobalPool - Add any method, instance or factory to global
327/// pool.
328void 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);
338}

340/// HasExplicitOwnershipAttr - returns true when pointer to ObjC pointer
341/// has explicit ownership attribute; false otherwise.
342static bool
343HasExplicitOwnershipAttr(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();
357}

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

PushExpressionEvaluationContext(ExprEvalContexts.back().Context);

// 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>());
    }
  }
}
496}

498namespace {

500// Callback to only accept typo corrections that are Objective-C classes.
501// If an ObjCInterfaceDecl* is given to the constructor, then the validation
502// function will reject corrections to that class.
503class ObjCInterfaceValidatorCCC final : 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);
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return llvm::make_unique<ObjCInterfaceValidatorCCC>(*this);
}

private:
ObjCInterfaceDecl *CurrentIDecl;
520};

522} // end anonymous namespace

524static void diagnoseUseOfProtocols(Sema &TheSema,
                                 ObjCContainerDecl *CD,
                                 ObjCProtocolDecl *const *ProtoRefs,
                                 unsigned NumProtoRefs,
                                 const SourceLocation *ProtoLocs) {
assert(ProtoRefs)((ProtoRefs) ? static_cast<void> (0) : __assert_fail ("ProtoRefs"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 529, __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);
}
538}

540void Sema::
541ActOnSuperClassOfClassInterface(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.
  ObjCInterfaceValidatorCCC CCC(IDecl);
  if (TypoCorrection Corrected = CorrectTypo(
          DeclarationNameInfo(SuperName, SuperLoc), LookupOrdinaryName,
          TUScope, nullptr, CCC, 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?")((!SuperClassDecl && "Failed to set SuperClassType?")
 ? static_cast<void> (0) : __assert_fail ("!SuperClassDecl && \"Failed to set SuperClassType?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 629, __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().getEndLoc());
}
663}

665DeclResult 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.getBeginLoc(),
                 diag::err_objc_type_param_bound_explicit_nullability)
                << paramName << typeBound
                << FixItHint::CreateRemoval(rangeToRemove);
            diagnosed = true;
          }
        }
      }

      if (!diagnosed) {
        Diag(qual ? qual.getBeginLoc()
                  : typeBoundInfo->getTypeLoc().getBeginLoc(),
             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);
767}

769ObjCTypeParamList *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);
802}

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

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

824/// Check consistency between two Objective-C type parameter lists, e.g.,
825/// between a category/extension and an \@interface or between an \@class and an
826/// \@interface.
827static 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()->getEndLoc());
  }

  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->getBeginLoc();

        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->getBeginLoc(),
                                               (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;
973}

975Decl *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")((ClassName && "Missing class identifier") ? static_cast
<void> (0) : __assert_fail ("ClassName && \"Missing class identifier\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 983, __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);
1100}

1102/// ActOnTypedefedProtocols - this action finds protocol list as part of the
1103/// typedef'ed use for a qualified super class and adds them to the list
1104/// of the protocols.
1105void 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);
    }
}
1128}

1130/// ActOnCompatibilityAlias - this action is called after complete parsing of
1131/// a \@compatibility_alias declaration. It sets up the alias relationships.
1132Decl *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;
1178}

1180bool 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;
1205}

1207Decl *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")((ProtocolName && "Missing protocol identifier") ? static_cast
<void> (0) : __assert_fail ("ProtocolName && \"Missing protocol identifier\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1214, __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);
1272}

1274static 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;
1287}

1289/// FindProtocolDeclaration - This routine looks up protocols and
1290/// issues an error if they are not declared. It returns list of
1291/// protocol declarations in its 'Protocols' argument.
1292void
1293Sema::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) {
    DeclFilterCCC<ObjCProtocolDecl> CCC{};
    TypoCorrection Corrected = CorrectTypo(
        DeclarationNameInfo(Pair.first, Pair.second), LookupObjCProtocolName,
        TUScope, nullptr, CCC, 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);
}
1335}

1337namespace {
1338// Callback to only accept typo corrections that are either
1339// Objective-C protocols or valid Objective-C type arguments.
1340class ObjCTypeArgOrProtocolValidatorCCC final
  : 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;
}

std::unique_ptr<CorrectionCandidateCallback> clone() override {
  return llvm::make_unique<ObjCTypeArgOrProtocolValidatorCCC>(*this);
}
1392};
1393} // end anonymous namespace

1395void 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);
1403}

1405void 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")((numProtocolsResolved == identifiers.size() && "Unresolved protocols"
) ? static_cast<void> (0) : __assert_fail ("numProtocolsResolved == identifiers.size() && \"Unresolved protocols\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1423, __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())((protocols.size() == identifierLocs.size()) ? static_cast<
void> (0) : __assert_fail ("protocols.size() == identifierLocs.size()"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1515, __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")((numTypeDeclsResolved == identifiers.size() && "Unresolved type decl"
) ? static_cast<void> (0) : __assert_fail ("numTypeDeclsResolved == identifiers.size() && \"Unresolved type decl\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1614, __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.
  ObjCTypeArgOrProtocolValidatorCCC CCC(Context, lookupKind);
  TypoCorrection corrected =
      CorrectTypo(DeclarationNameInfo(identifiers[i], identifierLocs[i]),
                  lookupKind, S, nullptr, CCC, 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?")((numTypeDeclsResolved == identifiers.size() && "Not all types?"
) ? static_cast<void> (0) : __assert_fail ("numTypeDeclsResolved == identifiers.size() && \"Not all types?\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 1737, __PRETTY_FUNCTION__));
return resolvedAsTypeDecls();
1739}

1741/// DiagnoseClassExtensionDupMethods - Check for duplicate declaration of
1742/// a class method in its extension.
1743///
1744void 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);
  }
}
1765}

1767/// ActOnForwardProtocolDeclaration - Handle \@protocol foo;
1768Sema::DeclGroupPtrTy
1769Sema::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);
1795}

1797Decl *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);
1888}

1890/// ActOnStartCategoryImplementation - Perform semantic checks on the
1891/// category implementation declaration and build an ObjCCategoryImplDecl
1892/// object.
1893Decl *Sema::ActOnStartCategoryImplementation(
                    SourceLocation AtCatImplLoc,
                    IdentifierInfo *ClassName, SourceLocation ClassLoc,
                    IdentifierInfo *CatName, SourceLocation CatLoc,
                    const ParsedAttributesView &Attrs) {
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();
}

ProcessDeclAttributeList(TUScope, CDecl, Attrs);
AddPragmaAttributes(TUScope, CDecl);

// 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);
1957}

1959Decl *Sema::ActOnStartClassImplementation(
                    SourceLocation AtClassImplLoc,
                    IdentifierInfo *ClassName, SourceLocation ClassLoc,
                    IdentifierInfo *SuperClassname,
                    SourceLocation SuperClassLoc,
                    const ParsedAttributesView &Attrs) {
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.
  ObjCInterfaceValidatorCCC CCC{};
  TypoCorrection Corrected =
      CorrectTypo(DeclarationNameInfo(ClassName, ClassLoc),
                  LookupOrdinaryName, TUScope, nullptr, CCC, 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);

ProcessDeclAttributeList(TUScope, IMPDecl, Attrs);
AddPragmaAttributes(TUScope, IMPDecl);

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);
2089}

2091Sema::DeclGroupPtrTy
2092Sema::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);
2108}

2110void Sema::CheckImplementationIvars(ObjCImplementationDecl *ImpDecl,
                                  ObjCIvarDecl **ivars, unsigned numIvars,
                                  SourceLocation RBrace) {
assert(ImpDecl && "missing implementation decl")((ImpDecl && "missing implementation decl") ? static_cast
<void> (0) : __assert_fail ("ImpDecl && \"missing implementation decl\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2113, __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")((ivars && "missing @implementation ivars") ? static_cast
<void> (0) : __assert_fail ("ivars && \"missing @implementation ivars\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2135, __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")((ImplIvar && "missing implementation ivar") ? static_cast
<void> (0) : __assert_fail ("ImplIvar && \"missing implementation ivar\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2172, __PRETTY_FUNCTION__));
  assert (ClsIvar && "missing class ivar")((ClsIvar && "missing class ivar") ? static_cast<void
> (0) : __assert_fail ("ClsIvar && \"missing class ivar\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2173, __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()->getBeginLoc(),
         diag::err_conflicting_ivar_bitwidth)
        << ImplIvar->getIdentifier();
    Diag(ClsIvar->getBitWidth()->getBeginLoc(),
         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);
2203}

2205static 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->getBeginLoc();
if (MethodLoc.isValid())
  S.Diag(MethodLoc, diag::note_method_declared_at) << method;
2230}

2232/// Determines if type B can be substituted for type A.  Returns true if we can
2233/// guarantee that anything that the user will do to an object of type A can
2234/// also be done to an object of type B.  This is trivially true if the two
2235/// types are the same, or if B is a subclass of A.  It becomes more complex
2236/// in cases where protocols are involved.
2237///
2238/// Object types in Objective-C describe the minimum requirements for an
2239/// object, rather than providing a complete description of a type.  For
2240/// example, if A is a subclass of B, then B* may refer to an instance of A.
2241/// The principle of substitutability means that we may use an instance of A
2242/// anywhere that we may use an instance of B - it will implement all of the
2243/// ivars of B and all of the methods of B.
2244///
2245/// This substitutability is important when type checking methods, because
2246/// the implementation may have stricter type definitions than the interface.
2247/// The interface specifies minimum requirements, but the implementation may
2248/// have more accurate ones.  For example, a method may privately accept
2249/// instances of B, but only publish that it accepts instances of A.  Any
2250/// object passed to it will be type checked against B, and so will implicitly
2251/// by a valid A*.  Similarly, a method may return a subclass of the class that
2252/// it is declared as returning.
2253///
2254/// This is most important when considering subclassing.  A method in a
2255/// subclass must accept any object as an argument that its superclass's
2256/// implementation accepts.  It may, however, accept a more general type
2257/// without breaking substitutability (i.e. you can still use the subclass
2258/// anywhere that you can use the superclass, but not vice versa).  The
2259/// converse requirement applies to return types: the return type for a
2260/// subclass method must be a valid object of the kind that the superclass
2261/// advertises, but it may be specified more accurately.  This avoids the need
2262/// for explicit down-casting by callers.
2263///
2264/// Note: This is a stricter requirement than for assignment.
2265static 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);
2297}

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

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

2310static 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;
2392}

2394static 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;
2475}

2477/// In ARC, check whether the conventional meanings of the two methods
2478/// match.  If they don't, it's a hard error.
2479static 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)((implFamily == OMF_None || declFamily == OMF_None) ? static_cast
<void> (0) : __assert_fail ("implFamily == OMF_None || declFamily == OMF_None"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2488, __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-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2511);
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;
2547}

2549void 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);
}
2573}

2575void 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);
}
2596}

2598/// WarnExactTypedMethods - This routine issues a warning if method
2599/// implementation declaration matches exactly that of its declaration.
2600void 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();
}
2639}

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

2647typedef llvm::DenseSet<IdentifierInfo*> ProtocolNameSet;
2648typedef std::unique_ptr<ProtocolNameSet> LazyProtocolNameSet;

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

2658/// Recursively populates a set with all conformed protocols in a class
2659/// hierarchy that have the 'objc_protocol_requires_explicit_implementation'
2660/// attribute.
2661static 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);
2670}

2672/// CheckProtocolMethodDefs - This routine checks unimplemented methods
2673/// Declared in protocol, and those referenced by it.
2674static 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")((IDecl && "CheckProtocolMethodDefs - IDecl is null")
 ? static_cast<void> (0) : __assert_fail ("IDecl && \"CheckProtocolMethodDefs - IDecl is null\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2685, __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);
2801}

2803/// MatchAllMethodDeclarations - Check methods declared in interface
2804/// or protocol against those declared in their implementations.
2805///
2806void 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*/) &&((CDecl->getInstanceMethod(I->getSelector(), true ) &&
 "Expected to find the method through lookup as well") ? static_cast
<void> (0) : __assert_fail ("CDecl->getInstanceMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2830, __PRETTY_FUNCTION__))
           "Expected to find the method through lookup as well")((CDecl->getInstanceMethod(I->getSelector(), true ) &&
 "Expected to find the method through lookup as well") ? static_cast
<void> (0) : __assert_fail ("CDecl->getInstanceMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2830, __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*/) &&((CDecl->getClassMethod(I->getSelector(), true ) &&
 "Expected to find the method through lookup as well") ? static_cast
<void> (0) : __assert_fail ("CDecl->getClassMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2856, __PRETTY_FUNCTION__))
           "Expected to find the method through lookup as well")((CDecl->getClassMethod(I->getSelector(), true ) &&
 "Expected to find the method through lookup as well") ? static_cast
<void> (0) : __assert_fail ("CDecl->getClassMethod(I->getSelector(), true ) && \"Expected to find the method through lookup as well\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 2856, __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 exact 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);
}
2908}

2910/// CheckCategoryVsClassMethodMatches - Checks that methods implemented in
2911/// category matches with those implemented in its primary class and
2912/// warns each time an exact match is found.
2913void 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*/);
2950}

2952void 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-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3028);
3029}

3031Sema::DeclGroupPtrTy
3032Sema::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);
3125}

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

3131static 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);
3186}

3188static bool tryMatchRecordTypes(ASTContext &Context,
                              Sema::MethodMatchStrategy strategy,
                              const Type *lt, const Type *rt) {
assert(lt && rt && lt != rt)((lt && rt && lt != rt) ? static_cast<void
> (0) : __assert_fail ("lt && rt && lt != rt"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3191, __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);
3222}

3224/// MatchTwoMethodDeclarations - Checks that two methods have matching type and
3225/// returns true, or false, accordingly.
3226/// TODO: Handle protocol list; such as id<p1,p2> in type comparisons
3227bool 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")((ri != right->param_end() && "Param mismatch") ? static_cast
<void> (0) : __assert_fail ("ri != right->param_end() && \"Param mismatch\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3250, __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;
3261}

3263static 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;
3281}

3283void 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));
3384}

3386/// Read the contents of the method pool for a given selector from
3387/// external storage.
3388void Sema::ReadMethodPool(Selector Sel) {
assert(ExternalSource && "We need an external AST source")((ExternalSource && "We need an external AST source")
 ? static_cast<void> (0) : __assert_fail ("ExternalSource && \"We need an external AST source\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3389, __PRETTY_FUNCTION__));
ExternalSource->ReadMethodPool(Sel);
3391}

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

3399void 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);
3417}

3419/// Determines if this is an "acceptable" loose mismatch in the global
3420/// method pool.  This exists mostly as a hack to get around certain
3421/// global mismatches which we can't afford to make warnings / errors.
3422/// Really, what we want is a way to take a method out of the global
3423/// method pool.
3424static 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());
3436}

3438/// Return true if the given method is wthin the type bound.
3439static 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!")((BoundInterface && "unexpected object type!") ? static_cast
<void> (0) : __assert_fail ("BoundInterface && \"unexpected object type!\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3449, __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-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3468);
3469}

3471/// We first select the type of the method: Instance or Factory, then collect
3472/// all methods with that type.
3473bool 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;
3510}

3512bool 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();
3535}

3537ObjCMethodDecl *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;
3555}

3557void 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]->getBeginLoc(),
       issueError ? diag::note_possibility : diag::note_using)
      << Methods[0]->getSourceRange();
  for (unsigned I = 1, N = Methods.size(); I != N; ++I) {
    Diag(Methods[I]->getBeginLoc(), diag::note_also_found)
        << Methods[I]->getSourceRange();
  }
}
3609}

3611ObjCMethodDecl *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;
3631}

3633static void
3634HelperSelectorsForTypoCorrection(
                    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);
}
3654}

3656static 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;
3664}

3666const ObjCMethodDecl *
3667Sema::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;
3722}

3724/// DiagnoseDuplicateIvars -
3725/// Check for duplicate ivars in the entire class at the start of
3726/// \@implementation. This becomes necesssary because class extension can
3727/// add ivars to a class in random order which will not be known until
3728/// class's \@implementation is seen.
3729void 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();
    }
  }
}
3743}

3745/// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.
3746static 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);
    }
  }
}
3760}

3762/// Diagnose attempts to use flexible array member with retainable object type.
3763static 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();
  }
}
3780}

3782Sema::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;
}
3800}

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

3809static 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();
    }
  }
}
3890}

3892// Note: For class/category implementations, allMethods is always null.
3893Decl *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'")((AtEnd.isValid() && "Invalid location for '@end'") ?
 static_cast<void> (0) : __assert_fail ("AtEnd.isValid() && \"Invalid location for '@end'\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 3898, __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 (IDecl->hasAttr<ObjCClassStubAttr>())
      Diag(IC->getLocation(), diag::err_implementation_of_class_stub);

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

  if (IntfDecl->hasAttr<ObjCClassStubAttr>() &&
      !IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>())
    Diag(IntfDecl->getLocation(), diag::err_class_stub_subclassing_mismatch);
}
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;
4123}

4125/// CvtQTToAstBitMask - utility routine to produce an AST bitmask for
4126/// objective-c's type qualifier from the parser version of the same info.
4127static Decl::ObjCDeclQualifier
4128CvtQTToAstBitMask(ObjCDeclSpec::ObjCDeclQualifier PQTVal) {
return (Decl::ObjCDeclQualifier) (unsigned) PQTVal;
4130}

4132/// Check whether the declared result type of the given Objective-C
4133/// method declaration is compatible with the method's class.
4134///
4135static Sema::ResultTypeCompatibilityKind
4136CheckRelatedResultTypeCompatibility(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;
4169}

4171namespace {
4172/// A helper class for searching for methods which a particular method
4173/// overrides.
4174class OverrideSearch {
4175public:
const ObjCMethodDecl *Method;
llvm::SmallSetVector<ObjCMethodDecl*, 4> Overridden;
bool Recursive;

4180public:
OverrideSearch(Sema &S, const ObjCMethodDecl *method) : 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;
  }
  const ObjCMethodList &list =
    method->isInstanceMethod() ? it->second.first : it->second.second;
  if (!list.getMethod()) return;

  const 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 (const ObjCCategoryDecl *Category =
          dyn_cast<ObjCCategoryDecl>(container)) {
    searchFromContainer(container);
    if (const 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(); }

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

  switch (container->getDeclKind()) {
4224#define OBJCCONTAINER(type, base) \
  case Decl::type: \
    searchFrom(cast<type##Decl>(container)); \
    break;
4228#define ABSTRACT_DECL(expansion)
4229#define DECL(type, base) \
  case Decl::type:
4231#include "clang/AST/DeclNodes.inc"
    llvm_unreachable("not an ObjC container!")::llvm::llvm_unreachable_internal("not an ObjC container!", "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4232);
  }
}

void searchFrom(const ObjCProtocolDecl *protocol) {
  if (!protocol->hasDefinition())
    return;

  // A method in a protocol declaration overrides declarations from
  // referenced ("parent") protocols.
  search(protocol->getReferencedProtocols());
}

void searchFrom(const 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(const 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 (const auto *Interface = impl->getClassInterface()) {
    search(Interface);
  }
}

void searchFrom(const 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(const ObjCImplementationDecl *impl) {
  // A method in a class implementation overrides declarations from
  // the class interface.
  if (const auto *Interface = impl->getClassInterface())
    search(Interface);
}

void search(const ObjCProtocolList &protocols) {
  for (const auto *Proto : protocols)
    search(Proto);
}

void search(const 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);
}
4316};
4317} // end anonymous namespace

4319void Sema::CheckObjCMethodOverrides(ObjCMethodDecl *ObjCMethod,
                                  ObjCInterfaceDecl *CurrentClass,
                                  ResultTypeCompatibilityKind RTC) {
if (!ObjCMethod)
  return;
// 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 (ObjCMethodDecl *overridden : overrides) {
  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 (ObjCMethodDecl *SuperOverridden : overrides) {
              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")((PrevI != overridden->param_end() && "Param mismatch"
) ? static_cast<void> (0) : __assert_fail ("PrevI != overridden->param_end() && \"Param mismatch\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4397, __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);
4413}

4415/// Merge type nullability from for a redeclaration of the same entity,
4416/// producing the updated type of the redeclared entity.
4417static 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);
4452}

4454/// Merge information from the declaration of a method in the \@interface
4455/// (or a category/extension) into the corresponding method in the
4456/// @implementation (for a class or category).
4457static void mergeInterfaceMethodToImpl(Sema &S,
                                     ObjCMethodDecl *method,
                                     ObjCMethodDecl *prevMethod) {
// Merge the objc_requires_super attribute.
if (prevMethod->hasAttr<ObjCRequiresSuperAttr>() &&
17
←
Taking true branch→
    !method->hasAttr<ObjCRequiresSuperAttr>()) {
  // merge the attribute into implementation.
  method->addAttr(
    ObjCRequiresSuperAttr::CreateImplicit(S.Context,
18
←
Calling 'ObjCRequiresSuperAttr::CreateImplicit'→
                                          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);
}
4496}

4498/// Verify that the method parameters/return value have types that are supported
4499/// by the x86 target.
4500static void checkObjCMethodX86VectorTypes(Sema &SemaRef,
                                        const ObjCMethodDecl *Method) {
assert(SemaRef.getASTContext().getTargetInfo().getTriple().getArch() ==((SemaRef.getASTContext().getTargetInfo().getTriple().getArch
() == llvm::Triple::x86 && "x86-specific check invoked for a different target"
) ? static_cast<void> (0) : __assert_fail ("SemaRef.getASTContext().getTargetInfo().getTriple().getArch() == llvm::Triple::x86 && \"x86-specific check invoked for a different target\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4504, __PRETTY_FUNCTION__))
           llvm::Triple::x86 &&((SemaRef.getASTContext().getTargetInfo().getTriple().getArch
() == llvm::Triple::x86 && "x86-specific check invoked for a different target"
) ? static_cast<void> (0) : __assert_fail ("SemaRef.getASTContext().getTargetInfo().getTriple().getArch() == llvm::Triple::x86 && \"x86-specific check invoked for a different target\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4504, __PRETTY_FUNCTION__))
       "x86-specific check invoked for a different target")((SemaRef.getASTContext().getTargetInfo().getTriple().getArch
() == llvm::Triple::x86 && "x86-specific check invoked for a different target"
) ? static_cast<void> (0) : __assert_fail ("SemaRef.getASTContext().getTargetInfo().getTriple().getArch() == llvm::Triple::x86 && \"x86-specific check invoked for a different target\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4504, __PRETTY_FUNCTION__));
SourceLocation Loc;
QualType T;
for (const ParmVarDecl *P : Method->parameters()) {
  if (P->getType()->isVectorType()) {
    Loc = P->getBeginLoc();
    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");
4539}

4541Decl *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 false branch→
  resultDeclType = GetTypeFromParser(ReturnType, &ReturnTInfo);

  if (CheckFunctionReturnType(resultDeclType, MethodLoc))
    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,
3
←
Assuming 'MethodType' is not equal to minus→
    /*isPropertyAccessor=*/false,
    /*isImplicitlyDeclared=*/false, /*isDefined=*/false,
    MethodDeclKind == tok::objc_optional ? ObjCMethodDecl::Optional
4
←
Assuming 'MethodDeclKind' is not equal to objc_optional→
5
←
'?' condition is false→
                                         : ObjCMethodDecl::Required,
    HasRelatedResultType);

SmallVector<ParmVarDecl*, 16> Params;

for (unsigned i = 0, e = Sel.getNumArgs(); i != e; ++i) {
6
←
Assuming 'i' is equal to 'e'→
7
←
Loop condition is false. Execution continues on line 4640→
  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) {
8
←
Assuming 'i' is equal to 'e'→
9
←
Loop condition is false. Execution continues on line 4653→
  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)) {
10
←
Taking true branch→
  if (MethodType == tok::minus) {
11
←
Taking false branch→
    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()) {
12
←
Assuming 'IDecl' is non-null→
13
←
Taking true branch→
    if (auto *IMD = IDecl->lookupMethod(ObjCMethod->getSelector(),
14
←
Assuming 'IMD' is non-null→
15
←
Taking true branch→
                                        ObjCMethod->isInstanceMethod())) {
      mergeInterfaceMethodToImpl(*this, ObjCMethod, IMD);
16
←
Calling 'mergeInterfaceMethodToImpl'→

      // 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() ==((ObjCMethod->parameters().size() == IMD->parameters().
size() && "Methods have different number of parameters"
) ? static_cast<void> (0) : __assert_fail ("ObjCMethod->parameters().size() == IMD->parameters().size() && \"Methods have different number of parameters\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4695, __PRETTY_FUNCTION__))
                     IMD->parameters().size() &&((ObjCMethod->parameters().size() == IMD->parameters().
size() && "Methods have different number of parameters"
) ? static_cast<void> (0) : __assert_fail ("ObjCMethod->parameters().size() == IMD->parameters().size() && \"Methods have different number of parameters\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4695, __PRETTY_FUNCTION__))
                 "Methods have different number of parameters")((ObjCMethod->parameters().size() == IMD->parameters().
size() && "Methods have different number of parameters"
) ? static_cast<void> (0) : __assert_fail ("ObjCMethod->parameters().size() == IMD->parameters().size() && \"Methods have different number of parameters\""
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 4695, __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) {
  // 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) {
  if (ObjCCategoryDecl *Cat = dyn_cast<ObjCCategoryDecl>(ClassDecl))
    CurrentClass = Cat->getClassInterface();
  else if (ObjCImplDecl *Impl = dyn_cast<ObjCImplDecl>(ClassDecl))
    CurrentClass = Impl->getClassInterface();
  else if (ObjCCategoryImplDecl *CatImpl
                                 = dyn_cast<ObjCCategoryImplDecl>(ClassDecl))
    CurrentClass = CatImpl->getClassInterface();
}

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

CheckObjCMethodOverrides(ObjCMethod, CurrentClass, RTC);

bool ARCError = false;
if (getLangOpts().ObjCAutoRefCount)
  ARCError = CheckARCMethodDecl(ObjCMethod);

// 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;
4791}

4793bool 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;
4808}

4810/// Called whenever \@defs(ClassName) is encountered in the source.  Inserts the
4811/// instance variables of ClassName into Decls.
4812void 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);
}
4850}

4852/// Build a type-check a new Objective-C exception variable declaration.
4853VarDecl *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;
4897}

4899Decl *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;
4953}

4955/// CollectIvarsToConstructOrDestruct - Collect those ivars which require
4956/// initialization.
4957void 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);
}
4965}

4967void 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;
}
4988}

4990ObjCIvarDecl *
4991Sema::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;
5013}

5015namespace {
/// 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)((IvarD) ? static_cast<void> (0) : __assert_fail ("IvarD"
, "/build/llvm-toolchain-snapshot-9~svn362543/tools/clang/lib/Sema/SemaDeclObjC.cpp"
, 5031, __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;
  }
};
5050} // end anonymous namespace

5052void 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);
  }
}
5082}

←

/build/llvm-toolchain-snapshot-9~svn362543/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 AArch64VectorPcsAttr : public InheritableAttr {
13public:
static AArch64VectorPcsAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AArch64VectorPcsAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

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

AArch64VectorPcsAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

36class AMDGPUFlatWorkGroupSizeAttr : public InheritableAttr {
37Expr * min;

39Expr * max;

41public:
static AMDGPUFlatWorkGroupSizeAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AMDGPUFlatWorkGroupSizeAttr(Loc, Ctx, Min, Max, 0);
  A->setImplicit(true);
  return A;
}

AMDGPUFlatWorkGroupSizeAttr(SourceRange R, ASTContext &Ctx
            , Expr * Min
            , Expr * 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;
Expr * getMin() const {
  return min;
}

Expr * getMax() const {
  return max;
}



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

76class AMDGPUNumSGPRAttr : public InheritableAttr {
77unsigned numSGPR;

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

108class AMDGPUNumVGPRAttr : public InheritableAttr {
109unsigned numVGPR;

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

140class AMDGPUWavesPerEUAttr : public InheritableAttr {
141Expr * min;

143Expr * max;

145public:
static AMDGPUWavesPerEUAttr *CreateImplicit(ASTContext &Ctx, Expr * Min, Expr * Max, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AMDGPUWavesPerEUAttr(Loc, Ctx, Min, Max, 0);
  A->setImplicit(true);
  return A;
}

AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
            , Expr * Min
            , Expr * Max
            , unsigned SI
           )
  : InheritableAttr(attr::AMDGPUWavesPerEU, R, SI, false, false)
            , min(Min)
            , max(Max)
{
}

AMDGPUWavesPerEUAttr(SourceRange R, ASTContext &Ctx
            , Expr * 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;
Expr * getMin() const {
  return min;
}

Expr * getMax() const {
  return max;
}



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

190class ARMInterruptAttr : public InheritableAttr {
191public:
enum InterruptType {
  IRQ,
  FIQ,
  SWI,
  ABORT,
  UNDEF,
  Generic
};
200private:
InterruptType interrupt;

203public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 260);
}


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

267class AVRInterruptAttr : public InheritableAttr {
268public:
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; }
289};

291class AVRSignalAttr : public InheritableAttr {
292public:
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; }
313};

315class AbiTagAttr : public Attr {
unsigned tags_Size;
StringRef *tags_;

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

368class AcquireCapabilityAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

372public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 412);
  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; }
434};

436class AcquiredAfterAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

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

481class AcquiredBeforeAttr : public InheritableAttr {
unsigned args_Size;
Expr * *args_;

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

526class AddressSpaceAttr : public TypeAttr {
527int addressSpace;

529public:
static AddressSpaceAttr *CreateImplicit(ASTContext &Ctx, int AddressSpace, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AddressSpaceAttr(Loc, Ctx, AddressSpace, 0);
  A->setImplicit(true);
  return A;
}

AddressSpaceAttr(SourceRange R, ASTContext &Ctx
            , int AddressSpace
            , unsigned SI
           )
  : TypeAttr(attr::AddressSpace, R, SI, false)
            , addressSpace(AddressSpace)
{
}

AddressSpaceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
int getAddressSpace() const {
  return addressSpace;
}



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

558class AliasAttr : public Attr {
559unsigned aliaseeLength;
560char *aliasee;

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

602class AlignMac68kAttr : public InheritableAttr {
603public:
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; }
624};

626class AlignValueAttr : public Attr {
627Expr * alignment;

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

658class AlignedAttr : public InheritableAttr {
659bool isalignmentExpr;
660union {
661Expr *alignmentExpr;
662TypeSourceInfo *alignmentType;
663};

665public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 707);
  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)((isalignmentExpr) ? static_cast<void> (0) : __assert_fail
 ("isalignmentExpr", "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 727, __PRETTY_FUNCTION__));
  return alignmentExpr;
}
TypeSourceInfo *getAlignmentType() const {
  assert(!isalignmentExpr)((!isalignmentExpr) ? static_cast<void> (0) : __assert_fail
 ("!isalignmentExpr", "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 731, __PRETTY_FUNCTION__));
  return alignmentType;
}



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

740class AllocAlignAttr : public InheritableAttr {
741ParamIdx paramIndex;

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

772class AllocSizeAttr : public InheritableAttr {
773ParamIdx elemSizeParam;

775ParamIdx numElemsParam;

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

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

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

AlwaysDestroyAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

846class AlwaysInlineAttr : public InheritableAttr {
847public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 873);
  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; }
882};

884class AnalyzerNoReturnAttr : public InheritableAttr {
885public:
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; }
906};

908class AnnotateAttr : public InheritableParamAttr {
909unsigned annotationLength;
910char *annotation;

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

952class AnyX86InterruptAttr : public InheritableAttr {
953public:
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; }
974};

976class AnyX86NoCallerSavedRegistersAttr : public InheritableAttr {
977public:
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; }
998};

1000class AnyX86NoCfCheckAttr : public InheritableAttr {
1001public:
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; }
1022};

1024class ArcWeakrefUnavailableAttr : public InheritableAttr {
1025public:
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; }
1046};

1048class ArgumentWithTypeTagAttr : public InheritableAttr {
1049IdentifierInfo * argumentKind;

1051ParamIdx argumentIdx;

1053ParamIdx typeTagIdx;

1055bool isPointer;

1057public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1114);
  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; }
1142};

1144class ArtificialAttr : public InheritableAttr {
1145public:
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; }
1166};

1168class AsmLabelAttr : public InheritableAttr {
1169unsigned labelLength;
1170char *label;

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

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

1216public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1254);
  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; }
1273};

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

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

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

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

1365class AssumeAlignedAttr : public InheritableAttr {
1366Expr * alignment;

1368Expr * offset;

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

1415class AvailabilityAttr : public InheritableAttr {
1416IdentifierInfo * platform;

1418VersionTuple introduced;


1421VersionTuple deprecated;


1424VersionTuple obsoleted;


1427bool unavailable;

1429unsigned messageLength;
1430char *message;

1432bool strict;

1434unsigned replacementLength;
1435char *replacement;

1437int priority;

1439public:
static AvailabilityAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted, bool Unavailable, llvm::StringRef Message, bool Strict, llvm::StringRef Replacement, int Priority, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) AvailabilityAttr(Loc, Ctx, Platform, Introduced, Deprecated, Obsoleted, Unavailable, Message, Strict, Replacement, Priority, 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
            , int Priority
            , 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])
            , priority(Priority)
{
    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);
}

int getPriority() const {
  return priority;
}

1542static 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)")
           .Case("swift", "Swift")
           .Default(llvm::StringRef());
1555}
1556static 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);
1567}
1568static 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);
1579} 

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

1584class BlocksAttr : public InheritableAttr {
1585public:
enum BlockType {
  ByRef
};
1589private:
BlockType type;

1592public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 1631);
}


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

1638class C11NoReturnAttr : public InheritableAttr {
1639public:
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; }
1660};

1662class CDeclAttr : public InheritableAttr {
1663public:
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; }
1684};

1686class CFAuditedTransferAttr : public InheritableAttr {
1687public:
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; }
1708};

1710class CFConsumedAttr : public InheritableParamAttr {
1711public:
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; }
1732};

1734class CFReturnsNotRetainedAttr : public InheritableAttr {
1735public:
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; }
1756};

1758class CFReturnsRetainedAttr : public InheritableAttr {
1759public:
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; }
1780};

1782class CFUnknownTransferAttr : public InheritableAttr {
1783public:
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; }
1804};

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

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

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

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



  IdentifierInfo *getCPUName(unsigned Index) const {
    return *(cpus_begin() + Index);
  }


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

1900class CUDAConstantAttr : public InheritableAttr {
1901public:
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; }
1922};

1924class CUDADeviceAttr : public InheritableAttr {
1925public:
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; }
1946};

1948class CUDAGlobalAttr : public InheritableAttr {
1949public:
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; }
1970};

1972class CUDAHostAttr : public InheritableAttr {
1973public:
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; }
1994};

1996class CUDAInvalidTargetAttr : public InheritableAttr {
1997public:
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; }
2018};

2020class CUDALaunchBoundsAttr : public InheritableAttr {
2021Expr * maxThreads;

2023Expr * minBlocks;

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

2070class CUDASharedAttr : public InheritableAttr {
2071public:
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; }
2092};

2094class CXX11NoReturnAttr : public InheritableAttr {
2095public:
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; }
2116};

2118class CallableWhenAttr : public InheritableAttr {
2119public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
2125private:
unsigned callableStates_Size;
ConsumedState *callableStates_;

2129public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2184);
}


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

2191class CallbackAttr : public InheritableAttr {
unsigned encoding_Size;
int *encoding_;

2195public:
static CallbackAttr *CreateImplicit(ASTContext &Ctx, int *Encoding, unsigned EncodingSize, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) CallbackAttr(Loc, Ctx, Encoding, EncodingSize, 0);
  A->setImplicit(true);
  return A;
}

CallbackAttr(SourceRange R, ASTContext &Ctx
            , int *Encoding, unsigned EncodingSize
            , unsigned SI
           )
  : InheritableAttr(attr::Callback, R, SI, false, false)
            , encoding_Size(EncodingSize), encoding_(new (Ctx, 16) int[encoding_Size])
{
  std::copy(Encoding, Encoding + encoding_Size, encoding_);
}

CallbackAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableAttr(attr::Callback, R, SI, false, false)
            , encoding_Size(0), encoding_(nullptr)
{
}

CallbackAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
typedef int* encoding_iterator;
encoding_iterator encoding_begin() const { return encoding_; }
encoding_iterator encoding_end() const { return encoding_ + encoding_Size; }
unsigned encoding_size() const { return encoding_Size; }
llvm::iterator_range<encoding_iterator> encoding() const { return llvm::make_range(encoding_begin(), encoding_end()); }




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

2236class CapabilityAttr : public InheritableAttr {
2237unsigned nameLength;
2238char *name;

2240public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2271);
  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; }
2299};

2301class CapturedRecordAttr : public InheritableAttr {
2302public:
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; }
2323};

2325class CarriesDependencyAttr : public InheritableParamAttr {
2326public:
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; }
2347};

2349class CleanupAttr : public InheritableAttr {
2350FunctionDecl * functionDecl;

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

2381class CodeSegAttr : public InheritableAttr {
2382unsigned nameLength;
2383char *name;

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

2425class ColdAttr : public InheritableAttr {
2426public:
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; }
2447};

2449class CommonAttr : public InheritableAttr {
2450public:
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; }
2471};

2473class ConstAttr : public InheritableAttr {
2474public:
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; }
2495};

2497class ConstructorAttr : public InheritableAttr {
2498int priority;

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

2539class ConsumableAttr : public InheritableAttr {
2540public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
2546private:
ConsumedState defaultState;

2549public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2592);
}


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

2599class ConsumableAutoCastAttr : public InheritableAttr {
2600public:
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; }
2621};

2623class ConsumableSetOnReadAttr : public InheritableAttr {
2624public:
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; }
2645};

2647class ConvergentAttr : public InheritableAttr {
2648public:
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; }
2669};

2671class DLLExportAttr : public InheritableAttr {
2672public:
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; }
2693};

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

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

DLLExportStaticLocalAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

2719class DLLImportAttr : public InheritableAttr {
2720public:
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;

2739private:
bool PropagatedToBaseTemplate = false;

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


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

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

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

DLLImportStaticLocalAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

2774class DeprecatedAttr : public InheritableAttr {
2775unsigned messageLength;
2776char *message;

2778unsigned replacementLength;
2779char *replacement;

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

2847class DestructorAttr : public InheritableAttr {
2848int priority;

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

2889class DiagnoseIfAttr : public InheritableAttr {
2890Expr * cond;

2892unsigned messageLength;
2893char *message;

2895public:
enum DiagnosticType {
  DT_Error,
  DT_Warning
};
2900private:
DiagnosticType diagnosticType;

2903bool argDependent;

2905NamedDecl * parent;

2907public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 2998);
}
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; }
3014};

3016class DisableTailCallsAttr : public InheritableAttr {
3017public:
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; }
3038};

3040class EmptyBasesAttr : public InheritableAttr {
3041public:
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; }
3062};

3064class EnableIfAttr : public InheritableAttr {
3065Expr * cond;

3067unsigned messageLength;
3068char *message;

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

3116class EnumExtensibilityAttr : public InheritableAttr {
3117public:
enum Kind {
  Closed,
  Open
};
3122private:
Kind extensibility;

3125public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3166);
}


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

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

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

ExcludeFromExplicitInstantiationAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

3197class ExclusiveTrylockFunctionAttr : public InheritableAttr {
3198Expr * successValue;

unsigned args_Size;
Expr * *args_;

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

3252class ExternalSourceSymbolAttr : public InheritableAttr {
3253unsigned languageLength;
3254char *language;

3256unsigned definedInLength;
3257char *definedIn;

3259bool generatedDeclaration;

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

3334class FallThroughAttr : public StmtAttr {
3335public:
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; }
3356};

3358class FastCallAttr : public InheritableAttr {
3359public:
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; }
3380};

3382class FinalAttr : public InheritableAttr {
3383public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 3408);
  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; }
3417};

3419class FlagEnumAttr : public InheritableAttr {
3420public:
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; }
3441};

3443class FlattenAttr : public InheritableAttr {
3444public:
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; }
3465};

3467class FormatAttr : public InheritableAttr {
3468IdentifierInfo * type;

3470int formatIdx;

3472int firstArg;

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

3515class FormatArgAttr : public InheritableAttr {
3516ParamIdx formatIdx;

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

3547class GNUInlineAttr : public InheritableAttr {
3548public:
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; }
3569};

3571class GuardedByAttr : public InheritableAttr {
3572Expr * arg;

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

3603class GuardedVarAttr : public InheritableAttr {
3604public:
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; }
3625};

3627class HotAttr : public InheritableAttr {
3628public:
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; }
3649};

3651class IBActionAttr : public InheritableAttr {
3652public:
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; }
3673};

3675class IBOutletAttr : public InheritableAttr {
3676public:
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; }
3697};

3699class IBOutletCollectionAttr : public InheritableAttr {
3700TypeSourceInfo * interface_;

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

3741class IFuncAttr : public Attr {
3742unsigned resolverLength;
3743char *resolver;

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

3785class InitPriorityAttr : public InheritableAttr {
3786unsigned priority;

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

3817class InitSegAttr : public Attr {
3818unsigned sectionLength;
3819char *section;

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

3865class IntelOclBiccAttr : public InheritableAttr {
3866public:
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; }
3887};

3889class InternalLinkageAttr : public InheritableAttr {
3890public:
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; }
3911};

3913class LTOVisibilityPublicAttr : public InheritableAttr {
3914public:
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; }
3935};

3937class LayoutVersionAttr : public InheritableAttr {
3938unsigned version;

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

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

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

LifetimeBoundAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

3993class LockReturnedAttr : public InheritableAttr {
3994Expr * arg;

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

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

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

4070class LoopHintAttr : public Attr {
4071public:
enum OptionType {
  Vectorize,
  VectorizeWidth,
  Interleave,
  InterleaveCount,
  Unroll,
  UnrollCount,
  UnrollAndJam,
  UnrollAndJamCount,
  PipelineDisabled,
  PipelineInitiationInterval,
  Distribute
};
4085private:
OptionType option;

4088public:
enum LoopHintState {
  Enable,
  Disable,
  Numeric,
  AssumeSafety,
  Full
};
4096private:
LoopHintState state;

4099Expr * value;

4101public:
enum Spelling {
  Pragma_clang_loop = 0,
  Pragma_unroll = 1,
  Pragma_nounroll = 2,
  Pragma_unroll_and_jam = 3,
  Pragma_nounroll_and_jam = 4
};

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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4135);
  case 0: return Pragma_clang_loop;
  case 1: return Pragma_unroll;
  case 2: return Pragma_nounroll;
  case 3: return Pragma_unroll_and_jam;
  case 4: return Pragma_nounroll_and_jam;
}
}
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("unroll_and_jam", LoopHintAttr::UnrollAndJam)
    .Case("unroll_and_jam_count", LoopHintAttr::UnrollAndJamCount)
    .Case("pipeline", LoopHintAttr::PipelineDisabled)
    .Case("pipeline_initiation_interval", LoopHintAttr::PipelineInitiationInterval)
    .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::UnrollAndJam: return "unroll_and_jam";
  case LoopHintAttr::UnrollAndJamCount: return "unroll_and_jam_count";
  case LoopHintAttr::PipelineDisabled: return "pipeline";
  case LoopHintAttr::PipelineInitiationInterval: return "pipeline_initiation_interval";
  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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4182);
}
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4211);
}
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 UnrollAndJam: return "unroll_and_jam";
  case UnrollAndJamCount: return "unroll_and_jam_count";
  case PipelineDisabled: return "pipeline";
  case PipelineInitiationInterval: return "pipeline_initiation_interval";
  case Distribute: return "distribute";
  }
  llvm_unreachable("Unhandled LoopHint option.")::llvm::llvm_unreachable_internal("Unhandled LoopHint option."
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4232);
}

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 || SpellingIndex == Pragma_nounroll_and_jam)
    return;
  else if (SpellingIndex == Pragma_unroll || SpellingIndex == Pragma_unroll_and_jam) {
    OS << ' ' << getValueString(Policy);
    return;
  }

  assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")((SpellingIndex == Pragma_clang_loop && "Unexpected spelling"
) ? static_cast<void> (0) : __assert_fail ("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4246, __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) : "");
  else if (SpellingIndex == Pragma_nounroll_and_jam)
    return "#pragma nounroll_and_jam";
  else if (SpellingIndex == Pragma_unroll_and_jam)
    return "#pragma unroll_and_jam" +
      (option == UnrollAndJamCount ? getValueString(Policy) : "");

  assert(SpellingIndex == Pragma_clang_loop && "Unexpected spelling")((SpellingIndex == Pragma_clang_loop && "Unexpected spelling"
) ? static_cast<void> (0) : __assert_fail ("SpellingIndex == Pragma_clang_loop && \"Unexpected spelling\""
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4283, __PRETTY_FUNCTION__));
  return getOptionName(option) + getValueString(Policy);
}


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

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

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

MIGServerRoutineAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

4315class MSABIAttr : public InheritableAttr {
4316public:
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; }
4337};

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

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

MSAllocatorAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

4363class MSInheritanceAttr : public InheritableAttr {
4364bool bestCase;

4366public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4409);
  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; }
4446};

4448class MSNoVTableAttr : public InheritableAttr {
4449public:
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; }
4470};

4472class MSP430InterruptAttr : public InheritableAttr {
4473unsigned number;

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

4504class MSStructAttr : public InheritableAttr {
4505public:
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; }
4526};

4528class MSVtorDispAttr : public InheritableAttr {
4529unsigned vdm;

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

4568class MaxFieldAlignmentAttr : public InheritableAttr {
4569unsigned alignment;

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

4600class MayAliasAttr : public InheritableAttr {
4601public:
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; }
4622};

4624class MicroMipsAttr : public InheritableAttr {
4625public:
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; }
4646};

4648class MinSizeAttr : public InheritableAttr {
4649public:
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; }
4670};

4672class MinVectorWidthAttr : public InheritableAttr {
4673unsigned vectorWidth;

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

4704class Mips16Attr : public InheritableAttr {
4705public:
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; }
4726};

4728class MipsInterruptAttr : public InheritableAttr {
4729public:
enum InterruptType {
  sw0,
  sw1,
  hw0,
  hw1,
  hw2,
  hw3,
  hw4,
  hw5,
  eic
};
4741private:
InterruptType interrupt;

4744public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4800);
}


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

4807class MipsLongCallAttr : public InheritableAttr {
4808public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4835);
  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; }
4845};

4847class MipsShortCallAttr : public InheritableAttr {
4848public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 4875);
  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; }
4885};

4887class ModeAttr : public Attr {
4888IdentifierInfo * mode;

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

4919class NSConsumedAttr : public InheritableParamAttr {
4920public:
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; }
4941};

4943class NSConsumesSelfAttr : public InheritableAttr {
4944public:
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; }
4965};

4967class NSReturnsAutoreleasedAttr : public InheritableAttr {
4968public:
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; }
4989};

4991class NSReturnsNotRetainedAttr : public InheritableAttr {
4992public:
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; }
5013};

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

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

NSReturnsRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

5039class NakedAttr : public InheritableAttr {
5040public:
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; }
5061};

5063class NoAliasAttr : public InheritableAttr {
5064public:
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; }
5085};

5087class NoCommonAttr : public InheritableAttr {
5088public:
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; }
5109};

5111class NoDebugAttr : public InheritableAttr {
5112public:
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; }
5133};

5135class NoDerefAttr : public TypeAttr {
5136public:
static NoDerefAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) NoDerefAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

NoDerefAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::NoDeref, R, SI, false)
{
}

NoDerefAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

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

NoDestroyAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

5183class NoDuplicateAttr : public InheritableAttr {
5184public:
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; }
5205};

5207class NoEscapeAttr : public Attr {
5208public:
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; }
5229};

5231class NoInlineAttr : public InheritableAttr {
5232public:
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; }
5253};

5255class NoInstrumentFunctionAttr : public InheritableAttr {
5256public:
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; }
5277};

5279class NoMicroMipsAttr : public InheritableAttr {
5280public:
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; }
5301};

5303class NoMips16Attr : public InheritableAttr {
5304public:
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; }
5325};

5327class NoReturnAttr : public InheritableAttr {
5328public:
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; }
5349};

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

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

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

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

NoSpeculativeLoadHardeningAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

5438class NoSplitStackAttr : public InheritableAttr {
5439public:
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; }
5460};

5462class NoStackProtectorAttr : public InheritableAttr {
5463public:
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; }
5484};

5486class NoThreadSafetyAnalysisAttr : public InheritableAttr {
5487public:
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; }
5508};

5510class NoThrowAttr : public InheritableAttr {
5511public:
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; }
5532};

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

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

5587class NotTailCalledAttr : public InheritableAttr {
5588public:
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; }
5609};

5611class OMPAllocateDeclAttr : public InheritableAttr {
5612public:
enum AllocatorTypeTy {
  OMPDefaultMemAlloc,
  OMPLargeCapMemAlloc,
  OMPConstMemAlloc,
  OMPHighBWMemAlloc,
  OMPLowLatMemAlloc,
  OMPCGroupMemAlloc,
  OMPPTeamMemAlloc,
  OMPThreadMemAlloc,
  OMPUserDefinedMemAlloc
};
5624private:
AllocatorTypeTy allocatorType;

5627Expr * allocator;

5629public:
static OMPAllocateDeclAttr *CreateImplicit(ASTContext &Ctx, AllocatorTypeTy AllocatorType, Expr * Allocator, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OMPAllocateDeclAttr(Loc, Ctx, AllocatorType, Allocator, 0);
  A->setImplicit(true);
  return A;
}

OMPAllocateDeclAttr(SourceRange R, ASTContext &Ctx
            , AllocatorTypeTy AllocatorType
            , Expr * Allocator
            , unsigned SI
           )
  : InheritableAttr(attr::OMPAllocateDecl, R, SI, false, false)
            , allocatorType(AllocatorType)
            , allocator(Allocator)
{
}

OMPAllocateDeclAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
AllocatorTypeTy getAllocatorType() const {
  return allocatorType;
}

static bool ConvertStrToAllocatorTypeTy(StringRef Val, AllocatorTypeTy &Out) {
  Optional<AllocatorTypeTy> R = llvm::StringSwitch<Optional<AllocatorTypeTy>>(Val)
    .Case("omp_default_mem_alloc", OMPAllocateDeclAttr::OMPDefaultMemAlloc)
    .Case("omp_large_cap_mem_alloc", OMPAllocateDeclAttr::OMPLargeCapMemAlloc)
    .Case("omp_const_mem_alloc", OMPAllocateDeclAttr::OMPConstMemAlloc)
    .Case("omp_high_bw_mem_alloc", OMPAllocateDeclAttr::OMPHighBWMemAlloc)
    .Case("omp_low_lat_mem_alloc", OMPAllocateDeclAttr::OMPLowLatMemAlloc)
    .Case("omp_cgroup_mem_alloc", OMPAllocateDeclAttr::OMPCGroupMemAlloc)
    .Case("omp_pteam_mem_alloc", OMPAllocateDeclAttr::OMPPTeamMemAlloc)
    .Case("omp_thread_mem_alloc", OMPAllocateDeclAttr::OMPThreadMemAlloc)
    .Case("", OMPAllocateDeclAttr::OMPUserDefinedMemAlloc)
    .Default(Optional<AllocatorTypeTy>());
  if (R) {
    Out = *R;
    return true;
  }
  return false;
}

static const char *ConvertAllocatorTypeTyToStr(AllocatorTypeTy Val) {
  switch(Val) {
  case OMPAllocateDeclAttr::OMPDefaultMemAlloc: return "omp_default_mem_alloc";
  case OMPAllocateDeclAttr::OMPLargeCapMemAlloc: return "omp_large_cap_mem_alloc";
  case OMPAllocateDeclAttr::OMPConstMemAlloc: return "omp_const_mem_alloc";
  case OMPAllocateDeclAttr::OMPHighBWMemAlloc: return "omp_high_bw_mem_alloc";
  case OMPAllocateDeclAttr::OMPLowLatMemAlloc: return "omp_low_lat_mem_alloc";
  case OMPAllocateDeclAttr::OMPCGroupMemAlloc: return "omp_cgroup_mem_alloc";
  case OMPAllocateDeclAttr::OMPPTeamMemAlloc: return "omp_pteam_mem_alloc";
  case OMPAllocateDeclAttr::OMPThreadMemAlloc: return "omp_thread_mem_alloc";
  case OMPAllocateDeclAttr::OMPUserDefinedMemAlloc: return "";
  }
  llvm_unreachable("No enumerator with that value")::llvm::llvm_unreachable_internal("No enumerator with that value"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5686);
}
Expr * getAllocator() const {
  return allocator;
}



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

5697class OMPCaptureKindAttr : public Attr {
5698unsigned captureKind;

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

5729class OMPCaptureNoInitAttr : public InheritableAttr {
5730public:
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; }
5751};

5753class OMPDeclareSimdDeclAttr : public Attr {
5754public:
enum BranchStateTy {
  BS_Undefined,
  BS_Inbranch,
  BS_Notinbranch
};
5760private:
BranchStateTy branchState;

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

5783public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 5863);
}
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; }
5963};

5965class OMPDeclareTargetDeclAttr : public InheritableAttr {
5966public:
enum MapTypeTy {
  MT_To,
  MT_Link
};
5971private:
MapTypeTy mapType;

5974public:
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
           )
  : InheritableAttr(attr::OMPDeclareTargetDecl, R, SI, false, 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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6015);
}

  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 llvm::Optional<MapTypeTy>
  isDeclareTargetDeclaration(const ValueDecl *VD) {
    if (!VD->hasAttrs())
      return llvm::None;
    if (const auto *Attr = VD->getAttr<OMPDeclareTargetDeclAttr>())
      return Attr->getMapType();

    return llvm::None;
  }


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

6037class OMPReferencedVarAttr : public Attr {
6038Expr * ref;

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

6069class OMPThreadPrivateDeclAttr : public InheritableAttr {
6070public:
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; }
6091};

6093class OSConsumedAttr : public InheritableParamAttr {
6094public:
static OSConsumedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OSConsumedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OSConsumedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : InheritableParamAttr(attr::OSConsumed, R, SI, false, false)
{
}

OSConsumedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

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

OSConsumesThisAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

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

OSReturnsNotRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

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

OSReturnsRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

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

OSReturnsRetainedOnNonZeroAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

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

OSReturnsRetainedOnZeroAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

6237class ObjCBoxableAttr : public Attr {
6238public:
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; }
6259};

6261class ObjCBridgeAttr : public InheritableAttr {
6262IdentifierInfo * bridgedType;

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

6293class ObjCBridgeMutableAttr : public InheritableAttr {
6294IdentifierInfo * bridgedType;

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

6325class ObjCBridgeRelatedAttr : public InheritableAttr {
6326IdentifierInfo * relatedClass;

6328IdentifierInfo * classMethod;

6330IdentifierInfo * instanceMethod;

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

6373class ObjCClassStubAttr : public Attr {
6374public:
static ObjCClassStubAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCClassStubAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCClassStubAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::ObjCClassStub, R, SI, false)
{
}

ObjCClassStubAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

6397class ObjCDesignatedInitializerAttr : public Attr {
6398public:
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; }
6419};

6421class ObjCExceptionAttr : public InheritableAttr {
6422public:
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; }
6443};

6445class ObjCExplicitProtocolImplAttr : public InheritableAttr {
6446public:
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; }
6467};

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

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

ObjCExternallyRetainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

6493class ObjCGCAttr : public TypeAttr {
6494IdentifierInfo * kind;

6496public:
static ObjCGCAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCGCAttr(Loc, Ctx, Kind, 0);
  A->setImplicit(true);
  return A;
}

ObjCGCAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Kind
            , unsigned SI
           )
  : TypeAttr(attr::ObjCGC, R, SI, false)
            , kind(Kind)
{
}

ObjCGCAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getKind() const {
  return kind;
}



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

6525class ObjCIndependentClassAttr : public InheritableAttr {
6526public:
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; }
6547};

6549class ObjCInertUnsafeUnretainedAttr : public TypeAttr {
6550public:
static ObjCInertUnsafeUnretainedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCInertUnsafeUnretainedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCInertUnsafeUnretainedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::ObjCInertUnsafeUnretained, R, SI, false)
{
}

ObjCInertUnsafeUnretainedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

6573class ObjCKindOfAttr : public TypeAttr {
6574public:
static ObjCKindOfAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCKindOfAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCKindOfAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::ObjCKindOf, R, SI, false)
{
}

ObjCKindOfAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

6597class ObjCMethodFamilyAttr : public InheritableAttr {
6598public:
enum FamilyKind {
  OMF_None,
  OMF_alloc,
  OMF_copy,
  OMF_init,
  OMF_mutableCopy,
  OMF_new
};
6607private:
FamilyKind family;

6610public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6659);
}


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

6666class ObjCNSObjectAttr : public InheritableAttr {
6667public:
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; }
6688};

6690class ObjCNonLazyClassAttr : public Attr {
6691public:
static ObjCNonLazyClassAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCNonLazyClassAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

ObjCNonLazyClassAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : Attr(attr::ObjCNonLazyClass, R, SI, false)
{
}

ObjCNonLazyClassAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

6714class ObjCOwnershipAttr : public InheritableAttr {
6715IdentifierInfo * kind;

6717public:
static ObjCOwnershipAttr *CreateImplicit(ASTContext &Ctx, IdentifierInfo * Kind, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCOwnershipAttr(Loc, Ctx, Kind, 0);
  A->setImplicit(true);
  return A;
}

ObjCOwnershipAttr(SourceRange R, ASTContext &Ctx
            , IdentifierInfo * Kind
            , unsigned SI
           )
  : InheritableAttr(attr::ObjCOwnership, R, SI, false, false)
            , kind(Kind)
{
}

ObjCOwnershipAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
IdentifierInfo * getKind() const {
  return kind;
}



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

6746class ObjCPreciseLifetimeAttr : public InheritableAttr {
6747public:
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; }
6768};

6770class ObjCRequiresPropertyDefsAttr : public InheritableAttr {
6771public:
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; }
6792};

6794class ObjCRequiresSuperAttr : public InheritableAttr {
6795public:
static ObjCRequiresSuperAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) ObjCRequiresSuperAttr(Loc, Ctx, 0);
19
←
'A' initialized to a null pointer value→
  A->setImplicit(true);
20
←
Called C++ object pointer is null
  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; }
6816};

6818class ObjCReturnsInnerPointerAttr : public InheritableAttr {
6819public:
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; }
6840};

6842class ObjCRootClassAttr : public InheritableAttr {
6843public:
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; }
6864};

6866class ObjCRuntimeNameAttr : public Attr {
6867unsigned metadataNameLength;
6868char *metadataName;

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

6910class ObjCRuntimeVisibleAttr : public Attr {
6911public:
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; }
6932};

6934class ObjCSubclassingRestrictedAttr : public InheritableAttr {
6935public:
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; }
6956};

6958class OpenCLAccessAttr : public Attr {
6959public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 6985);
  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; }
7003};

7005class OpenCLConstantAddressSpaceAttr : public TypeAttr {
7006public:
static OpenCLConstantAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLConstantAddressSpaceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OpenCLConstantAddressSpaceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::OpenCLConstantAddressSpace, R, SI, false)
{
}

OpenCLConstantAddressSpaceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7029class OpenCLGenericAddressSpaceAttr : public TypeAttr {
7030public:
static OpenCLGenericAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLGenericAddressSpaceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OpenCLGenericAddressSpaceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::OpenCLGenericAddressSpace, R, SI, false)
{
}

OpenCLGenericAddressSpaceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7053class OpenCLGlobalAddressSpaceAttr : public TypeAttr {
7054public:
static OpenCLGlobalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLGlobalAddressSpaceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OpenCLGlobalAddressSpaceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::OpenCLGlobalAddressSpace, R, SI, false)
{
}

OpenCLGlobalAddressSpaceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7077class OpenCLIntelReqdSubGroupSizeAttr : public InheritableAttr {
7078unsigned subGroupSize;

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

7109class OpenCLKernelAttr : public InheritableAttr {
7110public:
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; }
7131};

7133class OpenCLLocalAddressSpaceAttr : public TypeAttr {
7134public:
static OpenCLLocalAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLLocalAddressSpaceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OpenCLLocalAddressSpaceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::OpenCLLocalAddressSpace, R, SI, false)
{
}

OpenCLLocalAddressSpaceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7157class OpenCLPrivateAddressSpaceAttr : public TypeAttr {
7158public:
static OpenCLPrivateAddressSpaceAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) OpenCLPrivateAddressSpaceAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

OpenCLPrivateAddressSpaceAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::OpenCLPrivateAddressSpace, R, SI, false)
{
}

OpenCLPrivateAddressSpaceAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7181class OpenCLUnrollHintAttr : public InheritableAttr {
7182unsigned unrollHint;

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

7213class OptimizeNoneAttr : public InheritableAttr {
7214public:
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; }
7235};

7237class OverloadableAttr : public Attr {
7238public:
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; }
7259};

7261class OverrideAttr : public InheritableAttr {
7262public:
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; }
7283};

7285class OwnershipAttr : public InheritableAttr {
7286IdentifierInfo * module;

unsigned args_Size;
ParamIdx *args_;

7291public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7338);
  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; }
7380};

7382class PackedAttr : public InheritableAttr {
7383public:
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; }
7404};

7406class ParamTypestateAttr : public InheritableAttr {
7407public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
7413private:
ConsumedState paramState;

7416public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7459);
}


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

7466class PascalAttr : public InheritableAttr {
7467public:
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; }
7488};

7490class PassObjectSizeAttr : public InheritableParamAttr {
7491int type;

7493public:
enum Spelling {
  GNU_pass_object_size = 0,
  CXX11_clang_pass_object_size = 1,
  C2x_clang_pass_object_size = 2,
  GNU_pass_dynamic_object_size = 3,
  CXX11_clang_pass_dynamic_object_size = 4,
  C2x_clang_pass_dynamic_object_size = 5
};

static PassObjectSizeAttr *CreateImplicit(ASTContext &Ctx, Spelling S, int Type, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) PassObjectSizeAttr(Loc, Ctx, Type, S);
  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;
Spelling getSemanticSpelling() const {
switch (SpellingListIndex) {
  default: llvm_unreachable("Unknown spelling list index")::llvm::llvm_unreachable_internal("Unknown spelling list index"
, "/build/llvm-toolchain-snapshot-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7524);
  case 0: return GNU_pass_object_size;
  case 1: return CXX11_clang_pass_object_size;
  case 2: return C2x_clang_pass_object_size;
  case 3: return GNU_pass_dynamic_object_size;
  case 4: return CXX11_clang_pass_dynamic_object_size;
  case 5: return C2x_clang_pass_dynamic_object_size;
}
}
bool isDynamic() const { return SpellingListIndex == 3 ||
  SpellingListIndex == 4 ||
  SpellingListIndex == 5; }
int getType() const {
  return type;
}



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

7545class PcsAttr : public InheritableAttr {
7546public:
enum PCSType {
  AAPCS,
  AAPCS_VFP
};
7551private:
PCSType pCS;

7554public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 7595);
}


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

7602class PragmaClangBSSSectionAttr : public InheritableAttr {
7603unsigned nameLength;
7604char *name;

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

7646class PragmaClangDataSectionAttr : public InheritableAttr {
7647unsigned nameLength;
7648char *name;

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

7690class PragmaClangRodataSectionAttr : public InheritableAttr {
7691unsigned nameLength;
7692char *name;

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

7734class PragmaClangTextSectionAttr : public InheritableAttr {
7735unsigned nameLength;
7736char *name;

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

7778class PreserveAllAttr : public InheritableAttr {
7779public:
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; }
7800};

7802class PreserveMostAttr : public InheritableAttr {
7803public:
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; }
7824};

7826class PtGuardedByAttr : public InheritableAttr {
7827Expr * arg;

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

7858class PtGuardedVarAttr : public InheritableAttr {
7859public:
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; }
7880};

7882class Ptr32Attr : public TypeAttr {
7883public:
static Ptr32Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) Ptr32Attr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

Ptr32Attr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::Ptr32, R, SI, false)
{
}

Ptr32Attr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7906class Ptr64Attr : public TypeAttr {
7907public:
static Ptr64Attr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) Ptr64Attr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

Ptr64Attr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::Ptr64, R, SI, false)
{
}

Ptr64Attr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

7930class PureAttr : public InheritableAttr {
7931public:
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; }
7952};

7954class RISCVInterruptAttr : public InheritableAttr {
7955public:
enum InterruptType {
  user,
  supervisor,
  machine
};
7961private:
InterruptType interrupt;

7964public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8015);
}


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

8022class RegCallAttr : public InheritableAttr {
8023public:
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; }
8044};

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

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

ReinitializesAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

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

8074public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8116);
  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; }
8143};

8145class RenderScriptKernelAttr : public Attr {
8146public:
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; }
8167};

8169class ReqdWorkGroupSizeAttr : public InheritableAttr {
8170unsigned xDim;

8172unsigned yDim;

8174unsigned zDim;

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

8217class RequireConstantInitAttr : public InheritableAttr {
8218public:
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; }
8239};

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

8245public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8287);
  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; }
8312};

8314class RestrictAttr : public InheritableAttr {
8315public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8341);
  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; }
8350};

8352class ReturnTypestateAttr : public InheritableAttr {
8353public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
8359private:
ConsumedState state;

8362public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8405);
}


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

8412class ReturnsNonNullAttr : public InheritableAttr {
8413public:
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; }
8434};

8436class ReturnsTwiceAttr : public InheritableAttr {
8437public:
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; }
8458};

8460class SPtrAttr : public TypeAttr {
8461public:
static SPtrAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) SPtrAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

SPtrAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::SPtr, R, SI, false)
{
}

SPtrAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

8484class ScopedLockableAttr : public InheritableAttr {
8485public:
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; }
8506};

8508class SectionAttr : public InheritableAttr {
8509unsigned nameLength;
8510char *name;

8512public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8542);
  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; }
8564};

8566class SelectAnyAttr : public InheritableAttr {
8567public:
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; }
8588};

8590class SentinelAttr : public InheritableAttr {
8591int sentinel;

8593int nullPos;

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

8643class SetTypestateAttr : public InheritableAttr {
8644public:
enum ConsumedState {
  Unknown,
  Consumed,
  Unconsumed
};
8650private:
ConsumedState newState;

8653public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 8696);
}


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

8703class SharedTrylockFunctionAttr : public InheritableAttr {
8704Expr * successValue;

unsigned args_Size;
Expr * *args_;

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

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

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

SpeculativeLoadHardeningAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

8782class StdCallAttr : public InheritableAttr {
8783public:
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; }
8804};

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

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

8859class SwiftCallAttr : public InheritableAttr {
8860public:
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; }
8881};

8883class SwiftContextAttr : public ParameterABIAttr {
8884public:
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; }
8905};

8907class SwiftErrorResultAttr : public ParameterABIAttr {
8908public:
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; }
8929};

8931class SwiftIndirectResultAttr : public ParameterABIAttr {
8932public:
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; }
8953};

8955class SysVABIAttr : public InheritableAttr {
8956public:
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; }
8977};

8979class TLSModelAttr : public InheritableAttr {
8980unsigned modelLength;
8981char *model;

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

9023class TargetAttr : public InheritableAttr {
9024unsigned featuresStrLength;
9025char *featuresStr;

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

  StringRef getArchitecture() const {
    StringRef Features = getFeaturesStr();
    if (Features == "default") return {};

    SmallVector<StringRef, 1> AttrFeatures;
    Features.split(AttrFeatures, ",");

    for (auto &Feature : AttrFeatures) {
      Feature = Feature.trim();
      if (Feature.startswith("arch="))
        return Feature.drop_front(sizeof("arch=") - 1);
    }
    return "";
  }

  // Gets the list of features as simple string-refs with no +/- or 'no-'.
  // Only adds the items to 'Out' that are additions.
  void getAddedFeatures(llvm::SmallVectorImpl<StringRef> &Out) const {
    StringRef Features = getFeaturesStr();
    if (Features == "default") return;

    SmallVector<StringRef, 1> AttrFeatures;
    Features.split(AttrFeatures, ",");

    for (auto &Feature : AttrFeatures) {
      Feature = Feature.trim();

      if (!Feature.startswith("no-") && !Feature.startswith("arch=") &&
          !Feature.startswith("fpmath=") && !Feature.startswith("tune="))
        Out.push_back(Feature);
    }
  }

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

9156class TestTypestateAttr : public InheritableAttr {
9157public:
enum ConsumedState {
  Consumed,
  Unconsumed
};
9162private:
ConsumedState testState;

9165public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9206);
}


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

9213class ThisCallAttr : public InheritableAttr {
9214public:
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; }
9235};

9237class ThreadAttr : public Attr {
9238public:
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; }
9259};

9261class TransparentUnionAttr : public InheritableAttr {
9262public:
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; }
9283};

9285class TrivialABIAttr : public InheritableAttr {
9286public:
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; }
9307};

9309class TryAcquireCapabilityAttr : public InheritableAttr {
9310Expr * successValue;

unsigned args_Size;
Expr * *args_;

9315public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9357);
  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; }
9380};

9382class TypeNonNullAttr : public TypeAttr {
9383public:
static TypeNonNullAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TypeNonNullAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

TypeNonNullAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::TypeNonNull, R, SI, false)
{
}

TypeNonNullAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

9406class TypeNullUnspecifiedAttr : public TypeAttr {
9407public:
static TypeNullUnspecifiedAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TypeNullUnspecifiedAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

TypeNullUnspecifiedAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::TypeNullUnspecified, R, SI, false)
{
}

TypeNullUnspecifiedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

9430class TypeNullableAttr : public TypeAttr {
9431public:
static TypeNullableAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) TypeNullableAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

TypeNullableAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::TypeNullable, R, SI, false)
{
}

TypeNullableAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

9454class TypeTagForDatatypeAttr : public InheritableAttr {
9455IdentifierInfo * argumentKind;

9457TypeSourceInfo * matchingCType;

9459bool layoutCompatible;

9461bool mustBeNull;

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

9512class TypeVisibilityAttr : public InheritableAttr {
9513public:
enum VisibilityType {
  Default,
  Hidden,
  Protected
};
9519private:
VisibilityType visibility;

9522public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9566);
}


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

9573class UPtrAttr : public TypeAttr {
9574public:
static UPtrAttr *CreateImplicit(ASTContext &Ctx, SourceRange Loc = SourceRange()) {
  auto *A = new (Ctx) UPtrAttr(Loc, Ctx, 0);
  A->setImplicit(true);
  return A;
}

UPtrAttr(SourceRange R, ASTContext &Ctx
            , unsigned SI
           )
  : TypeAttr(attr::UPtr, R, SI, false)
{
}

UPtrAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

9597class UnavailableAttr : public InheritableAttr {
9598unsigned messageLength;
9599char *message;

9601public:
enum ImplicitReason {
  IR_None,
  IR_ARCForbiddenType,
  IR_ForbiddenWeak,
  IR_ARCForbiddenConversion,
  IR_ARCInitReturnsUnrelated,
  IR_ARCFieldWithOwnership
};
9610private:
ImplicitReason implicitReason;

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

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

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

UninitializedAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;


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

9710class UnusedAttr : public InheritableAttr {
9711public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9738);
  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; }
9748};

9750class UsedAttr : public InheritableAttr {
9751public:
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; }
9772};

9774class UuidAttr : public InheritableAttr {
9775unsigned guidLength;
9776char *guid;

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

9818class VecReturnAttr : public InheritableAttr {
9819public:
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; }
9840};

9842class VecTypeHintAttr : public InheritableAttr {
9843TypeSourceInfo * typeHint;

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

9876class VectorCallAttr : public InheritableAttr {
9877public:
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; }
9898};

9900class VisibilityAttr : public InheritableAttr {
9901public:
enum VisibilityType {
  Default,
  Hidden,
  Protected
};
9907private:
VisibilityType visibility;

9910public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 9954);
}


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

9961class WarnUnusedAttr : public InheritableAttr {
9962public:
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; }
9983};

9985class WarnUnusedResultAttr : public InheritableAttr {
9986public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 10014);
  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; }
10025};

10027class WeakAttr : public InheritableAttr {
10028public:
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; }
10049};

10051class WeakImportAttr : public InheritableAttr {
10052public:
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; }
10073};

10075class WeakRefAttr : public InheritableAttr {
10076unsigned aliaseeLength;
10077char *aliasee;

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

10127class WebAssemblyImportModuleAttr : public InheritableAttr {
10128unsigned importModuleLength;
10129char *importModule;

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

WebAssemblyImportModuleAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef ImportModule
            , unsigned SI
           )
  : InheritableAttr(attr::WebAssemblyImportModule, R, SI, false, false)
            , importModuleLength(ImportModule.size()),importModule(new (Ctx, 1) char[importModuleLength])
{
    if (!ImportModule.empty())
      std::memcpy(importModule, ImportModule.data(), importModuleLength);
}

WebAssemblyImportModuleAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getImportModule() const {
  return llvm::StringRef(importModule, importModuleLength);
}
unsigned getImportModuleLength() const {
  return importModuleLength;
}
void setImportModule(ASTContext &C, llvm::StringRef S) {
  importModuleLength = S.size();
  this->importModule = new (C, 1) char [importModuleLength];
  if (!S.empty())
    std::memcpy(this->importModule, S.data(), importModuleLength);
}



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

10171class WebAssemblyImportNameAttr : public InheritableAttr {
10172unsigned importNameLength;
10173char *importName;

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

WebAssemblyImportNameAttr(SourceRange R, ASTContext &Ctx
            , llvm::StringRef ImportName
            , unsigned SI
           )
  : InheritableAttr(attr::WebAssemblyImportName, R, SI, false, false)
            , importNameLength(ImportName.size()),importName(new (Ctx, 1) char[importNameLength])
{
    if (!ImportName.empty())
      std::memcpy(importName, ImportName.data(), importNameLength);
}

WebAssemblyImportNameAttr *clone(ASTContext &C) const;
void printPretty(raw_ostream &OS,
                 const PrintingPolicy &Policy) const;
const char *getSpelling() const;
llvm::StringRef getImportName() const {
  return llvm::StringRef(importName, importNameLength);
}
unsigned getImportNameLength() const {
  return importNameLength;
}
void setImportName(ASTContext &C, llvm::StringRef S) {
  importNameLength = S.size();
  this->importName = new (C, 1) char [importNameLength];
  if (!S.empty())
    std::memcpy(this->importName, S.data(), importNameLength);
}



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

10215class WorkGroupSizeHintAttr : public InheritableAttr {
10216unsigned xDim;

10218unsigned yDim;

10220unsigned zDim;

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

10263class X86ForceAlignArgPointerAttr : public InheritableAttr {
10264public:
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; }
10285};

10287class XRayInstrumentAttr : public InheritableAttr {
10288public:
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-9~svn362543/build-llvm/tools/clang/include/clang/AST/Attrs.inc"
, 10317);
  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; }
10335};

10337class XRayLogArgsAttr : public InheritableAttr {
10338unsigned argumentCount;

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

10369#endif // LLVM_CLANG_ATTR_CLASSES_INC