Module:ClangDiags/DiagsLongData0: Difference between revisions

local m="Update tablegen diagnostic files to be in sync with the def files.\n\nllvm-svn: 67004";

local n="clang/lib/Sema/SemaDecl.cpp";

local o="clang/lib/Sema/SemaType.cpp";

local p="clang/lib/Sema/SemaChecking.cpp";

local r="clang/lib/Sema/SemaDeclCXX.cpp";

local s="clang/lib/Sema/SemaCast.cpp";

local t="clang/lib/Sema/SemaExprCXX.cpp";

local u="clang/lib/Sema/SemaExpr.cpp";

local v="Parse Issue";

local x="b1c4d5507fad";

local y="The basic representation of diagnostics information in tablegen format, plus (uncommented and incomp...";

local z="Inline Assembly Issue";

local A="clang/lib/Parse/ParseDecl.cpp";

local B="clang/lib/Sema/SemaStmtAsm.cpp";

local D="clang/lib/Sema/SemaInit.cpp";

local E="31168b077c36";

local F="Automatic Reference Counting.\n\nLanguage-design credit goes to a lot of people, but I particularly wa...";

local H="Automatic Reference Counting.\n\nLanguage-design credit goes to a lot of people, but I particularly want\nto single out Blaine Garst and Patrick Beard for their contributions.\n\nCompiler implementation credit goes to Argyrios, Doug, Fariborz, and myself,\nin no particular order.\n\nllvm-svn: 133103";

local I="clang/lib/Parse/ParseDeclCXX.cpp";

local J="ARC Semantic Issue";

local K="Implement P2361 Unevaluated string literals\n\nThis patch proposes to handle in an uniform fashion\nthe...";

local M="95f50964fbf5";

local N="clang/test/Sema/asm.c";

local O="clang/lib/Frontend/CompilerInvocation.cpp";

local P="clang/lib/Sema/SemaObjCProperty.cpp";

local Q="clang/lib/Sema/SemaStmt.cpp";

local R="clang/lib/Sema/SemaOverload.cpp";

local S="[clang] Implement objc_non_runtime_protocol to remove protocol metadata\n\nSummary:\nMotivated by the new objc_direct attribute, this change adds a new\nattribute that remotes metadata from Protocols that the programmer knows\nisn\'t going to be used at runtime. We simply have the frontend skip\ngenerating any protocol metadata entries (e.g. OBJC_CLASS_NAME,\n_OBJC_$_PROTOCOL_INSTANCE_METHDOS, _OBJC_PROTOCOL, etc) for a protocol\nmarked with `__attribute__((objc_non_runtime_protocol))`.\n\nThere are a few APIs used to retrieve a protocol at runtime.\n`@protocol(SomeProtocol)` will now error out of the requested protocol\nis marked with attribute. `objc_getProtocol` will return `NULL` which\nis consistent with the behavior of a non-existing protocol.\n\nSubscribers: cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D75574";

local T="Implement the C++0x deduced \'auto\' feature.\n\nThis fixes PR 8738, 9060 and 9132.\n\nllvm-svn: 126069";

local U="clang/lib/Sema/SemaAccess.cpp";

local V="Mass-rename the handful of error_* diagnostics to err_*.\n\nllvm-svn: 288545";

local W="[clang] Implement objc_non_runtime_protocol to remove protocol metadata\n\nSummary:\nMotivated by the n...";

local X="14f6bfcb52e7";

local Z="[WebAssembly] Improve clang diagnostics for wasm attributes\n\nThis patch addresses the review comment...";

local ab="931fcd3ba011";

local bb="clang/lib/ARCMigrate/TransProperties.cpp";

local db="cff00d9c127c";

local eb="Rename objc_lifetime -> objc_ownership, and modify diagnostics to talk about \'ownership\', not \'lifetime\'.\n\nrdar://9477613.\n\nllvm-svn: 133779";

local fb="61d065e21ff3";

local hb="constexpr: semantic checking for constexpr functions and constructors. Based in\npart on patches by Peter Collingbourne.\n\nWe diverge from the C++11 standard in a few areas, mostly related to checking\nconstexpr function declarations, and not just definitions. See WG21 paper\nN3308=11-0078 for details.\n\nFunction invocation substitution is not available in this patch; constexpr\nfunctions cannot yet be used from within constant expressions.\n\nllvm-svn: 140926";

local ib="eb3c10c248ac";

local jb="Let clang atomic builtins fetch add/sub support floating point types\n\nRecently atomicrmw started to ...";

local kb="constexpr: semantic checking for constexpr functions and constructors. Based in\npart on patches by P...";

local lb="Let clang atomic builtins fetch add/sub support floating point types\n\nRecently atomicrmw started to support fadd/fsub:\n\nhttps://reviews.llvm.org/D53965\n\nHowever clang atomic builtins fetch add/sub still does not support\nemitting atomicrmw fadd/fsub.\n\nThis patch adds that.\n\nReviewed by: John McCall, Artem Belevich, Matt Arsenault, JF Bastien,\nJames Y Knight, Louis Dionne, Olivier Giroux\n\nDifferential Revision: https://reviews.llvm.org/D71726";

local nb="f9c3310d32c6";

local ob="[OPENMP]Fix PR49366: crash on VLAs in task untied regions.\n\nWe need to capture the local variables i...";

local pb="[OPENMP]Fix PR49366: crash on VLAs in task untied regions.\n\nWe need to capture the local variables into a record in task untied\nregions but clang does not support record with VLA data members.\n\nDifferential Revision: https://reviews.llvm.org/D99436";

local qb="ac991bbb4456";

local rb="Emit !callback metadata and introduce the callback attribute\n\n  With commit r351627, LLVM gained the...";

local sb="clang/lib/Sema/SemaLambda.cpp";

local tb="2a7d481faf54";

local ub="clang/test/Sema/builtins.c";

local vb="Implement most of N3638 (return type deduction for normal functions).\nMissing (somewhat ironically) is support for the new deduction rules\nin lambda functions, plus PCH support for return type patching.\n\nllvm-svn: 181108";

local wb="clang/lib/AST/Stmt.cpp";

local xb="ARC Restrictions";

local yb="Emit !callback metadata and introduce the callback attribute\n\n  With commit r351627, LLVM gained the ability to apply (existing) IPO\n  optimizations on indirections through callbacks, or transitive calls.\n  The general idea is that we use an abstraction to hide the middle man\n  and represent the callback call in the context of the initial caller.\n  It is described in more detail in the commit message of the LLVM patch\n  r351627, the llvm::AbstractCallSite class description, and the\n  language reference section on callback-metadata.\n\n  This commit enables clang to emit !callback metadata that is\n  understood by LLVM. It does so in three different cases:\n    1) For known broker functions declarations that are directly\n      generated, e.g., __kmpc_fork_call for the OpenMP pragma parallel.\n    2) For known broker functions that are identified by their name and\n      source location through the builtin detection, e.g.,\n      pthread_create from the POSIX thread API.\n    3) For user annotated functions that carry the \"callback(callee, ...)\"\n      attribute. The attribute has to include the name, or index, of\n      the callback callee and how the passed arguments can be\n      identified (as many as the callback callee has). See the callback\n      attribute documentation for detailed information.\n\nDifferential Revision: https://reviews.llvm.org/D55483\n\nllvm-svn: 351629";

local zb="clang/test/SemaObjC/arc.m";

local Ab="clang/test/SemaCXX/dynamic-cast.cpp";

local Bb="Implement most of N3638 (return type deduction for normal functions).\nMissing (somewhat ironically) ...";

local Cb="clang/lib/Parse/ParseExpr.cpp";

local Eb="Perform access control for the implicit base and member destructor calls\nrequired when emitting a de...";

local Gb="Improve handling of vector casts in C++.\n\nllvm-svn: 82072";

local Hb="clang/test/SemaCXX/conversion-function.cpp";

local Ib="30482bc78659";

local Jb="clang/lib/Lex/Lexer.cpp";

local Kb="clang/test/Parser/cxx2a-concept-declaration.cpp";

local Lb="clang/lib/Sema/SemaTemplateDeduction.cpp";

local Mb="f881267db9a9";

local Nb="AMDGPU: Teach toolchain to link rocm device libs\n\nCurrently the library is separately linked, but this isn\'t correct to\nimplement fast math flags correctly. Each module should get the\nversion of the library appropriate for its combination of fast math\nand related flags, with the attributes propagated into its functions\nand internalized.\n\nHIP already maintains the list of libraries, but this is not used for\nOpenCL. Unfortunately, HIP uses a separate --hip-device-lib argument,\ndespite both languages using the same bitcode library. Eventually\nthese two searches need to be merged.\n\nAn additional problem is there are 3 different locations the libraries\nare installed, depending on which build is used. This also needs to be\nconsolidated (or at least the search logic needs to deal with this\nunnecessary complexity).";

local Ob="AMDGPU: Teach toolchain to link rocm device libs\n\nCurrently the library is separately linked, but th...";

local Pb="4593e4131aff";

local Qb="clang/test/Sema/attr-callback-broken.c";

local Rb="ARC Weak References";

local Sb="[ObjC] Implement @available in the Parser and AST\n\nThis patch adds a new AST node: ObjCAvailabilityCheckExpr, and teaches the\nParser and Sema to generate it. This node represents an availability check of\nthe form:\n\n  @available(macos 10.10, *);\n\nWhich will eventually compile to a runtime check of the host\'s OS version. This\nis the first patch of the feature I proposed here:\nhttp://lists.llvm.org/pipermail/cfe-dev/2016-July/049851.html\n\nDifferential Revision: https://reviews.llvm.org/D22171\n\nllvm-svn: 275654";

local Tb="3dbcea8b957a";

local Ub="Reland [clang] Check unsupported types in expressions\n\nThis was committed as ec6c847179fd, but then ...";

local Vb="Reland [clang] Check unsupported types in expressions\n\nThis was committed as ec6c847179fd, but then reverted after a failure\nin: https://lab.llvm.org/buildbot/#/builders/84/builds/13983\n\nI was not able to reproduce the problem, but I added an extra check\nfor a NULL QualType just in case.\n\nOriginal comit message:\n\nThe patch adds missing diagnostics for cases like:\n\n  float F3 = ((__float128)F1 * (__float128)F2) / 2.0f;\n\nSema::checkDeviceDecl (renamed to checkTypeSupport) is changed to work\nwith a type without the corresponding ValueDecl. It is also refactored\nso that host diagnostics for unsupported types can be added here as\nwell.\n\nDifferential Revision: https://reviews.llvm.org/D109315";

local dc="29099ded0c15";

[b]={x,1236199783,y,w},

[h]={{Jb,1359,"/// getCharAndSizeSlow - Peek a single \'character\' from the specified buffer,\n/// get its size, and return it.  This is tricky in several cases:\n///  1. If currently at the start of a trigraph, we warn about the trigraph,\n///      then either return the trigraph (skipping 3 chars) or the \'?\',\n///      depending on whether trigraphs are enabled or not.\n///  2. If this is an escaped newline (potentially with whitespace between\n///      the backslash and newline), implicitly skip the newline and return\n///      the char after it.\n///\n/// This handles the slow/uncommon case of the getCharAndSize method.  Here we\n/// know that we can accumulate into Size, and that we have already incremented\n/// Ptr by Size bytes.\n///\n/// NOTE: When this method is updated, getCharAndSizeSlowNoWarn (below) should\n/// be updated to match.\nchar Lexer::getCharAndSizeSlow(const char *Ptr, unsigned &Size, Token *Tok) {\n  // ...\n  Slash:\n    // ...\n    // See if we have optional whitespace characters between the slash and\n    // newline.\n    if (unsigned EscapedNewLineSize = getEscapedNewLineSize(Ptr)) {\n      // ...\n      // Warn if there was whitespace between the backslash and newline.\n      if (Ptr[0] != \'\\n\' && Ptr[0] != \'\\r\' && Tok && !isLexingRawMode())\n        Diag(Ptr, diag::backslash_newline_space);"},{Jb,2511,"/// We have just read the // characters from input.  Skip until we find the\n/// newline character that terminates the comment.  Then update BufferPtr and\n/// return.\n///\n/// If we\'re in KeepCommentMode or any CommentHandler has inserted\n/// some tokens, this will store the first token and return true.\nbool Lexer::SkipLineComment(Token &Result, const char *CurPtr, bool &TokAtPhysicalStartOfLine) {\n  // ...\n  while (true) {\n    // ...\n    if (C != 0) {\n      // ...\n      // If there was space between the backslash and newline, warn about it.\n      if (HasSpace && !isLexingRawMode())\n        Diag(EscapePtr, diag::backslash_newline_space);"},{Jb,2699,"/// isBlockCommentEndOfEscapedNewLine - Return true if the specified newline\n/// character (either \\\\n or \\\\r) is part of an escaped newline sequence.  Issue\n/// a diagnostic if so.  We know that the newline is inside of a block comment.\nstatic bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr, Lexer *L, bool Trigraphs) {\n  // ...\n  // If there was space between the backslash and newline, warn about it.\n  if (SpacePos && !L->isLexingRawMode())\n    L->Diag(SpacePos, diag::backslash_newline_space);"}},

[h]={{p,5982,"bool Sema::CheckX86BuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  // ...\n  if (TT.getArch() != llvm::Triple::x86 && isX86_32Builtin(BuiltinID))\n    return Diag(TheCall->getCallee()->getBeginLoc(), diag::err_32_bit_builtin_64_bit_tgt);"}},

[b]={"239eec732ebf",1428623896,"Add Clang support for remaining integer divide and permute instructions from ISA 2.06\n\nThis patch co...","Add Clang support for remaining integer divide and permute instructions from ISA 2.06\n\nThis patch corresponds to review:\nhttp://reviews.llvm.org/D8398\n\nIt adds some builtin functions to access the extended divide and bit permute instructions.\n\nllvm-svn: 234547"},

[h]={{p,4249,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  // ...\n  if (isPPC_64Builtin(BuiltinID) && !IsTarget64Bit)\n    return Diag(TheCall->getBeginLoc(), diag::err_64_bit_builtin_32_bit_tgt) << TheCall->getSourceRange();"}},

[b]={x,1236199783,y,w},

[h]={{Xb,219,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  // ...\n  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Xb,226,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  // ...\n  if (!tok::isStringLiteral(Tok.getKind())) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Xb,254,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  // ...\n  if (Tok.isNot(tok::r_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Xb,270,"/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then\n/// return the first token after the directive.  The _Pragma token has just\n/// been read into \'Tok\'.\nvoid Preprocessor::Handle_Pragma(Token &Tok) {\n  // ...\n  if (Invalid) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Xb,370,"/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text\n/// is not enclosed within a string literal.\nvoid Preprocessor::HandleMicrosoft__pragma(Token &Tok) {\n  // ...\n  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"}},

[b]={"bf17ecf59a9b",1457537453,"[GCC] PR23529 Sema part of attrbute abi_tag support\n\nOriginal patch by Stefan Bühler http://reviews...","[GCC] PR23529 Sema part of attrbute abi_tag support\n\nOriginal patch by Stefan Bühler http://reviews.llvm.org/D12834\n\nDifference between original and this one:\n- fixed all comments in original code review\n- added more tests, all new diagnostics now covered by tests\n- moved abi_tag on re-declaration checks to Sema::mergeDeclAttributes\n  where they actually may work as designed\n- clang-format + other stylistic changes\n\nMangle part will be sent for review as a separate patch.\n\nDifferential Revision: http://reviews.llvm.org/D17567\n\nllvm-svn: 263015"},

[h]={{n,3263,"/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.\nvoid Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK) {\n  // ...\n  // Re-declaration cannot add abi_tag\'s.\n  if (const auto *NewAbiTagAttr = New->getAttr<AbiTagAttr>()) {\n    if (const auto *OldAbiTagAttr = Old->getAttr<AbiTagAttr>()) {\n    // ...\n    } else {\n      Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);"}},

[b]={"576cc6f725a8",1237753097,"Disallow abstract types where appropriate.\n\nllvm-svn: 67476","Disallow abstract types where appropriate.\n\nllvm-svn: 67476"},

[h]={{p,16642,"/// CheckParmsForFunctionDef - Check that the parameters of the given\n/// function are appropriate for the definition of a function. This\n/// takes care of any checks that cannot be performed on the\n/// declaration itself, e.g., that the types of each of the function\n/// parameters are complete.\nbool Sema::CheckParmsForFunctionDef(ArrayRef<ParmVarDecl *> Parameters, bool CheckParameterNames) {\n  // ...\n  for (ParmVarDecl *Param : Parameters) {\n    // ...\n    if (!Param->isInvalidDecl() && (RequireCompleteType(Param->getLocation(), Param->getType(), diag::err_typecheck_decl_incomplete_type) || RequireNonAbstractType(Param->getBeginLoc(), Param->getOriginalType(), diag::err_abstract_type_in_decl, AbstractParamType))) {"},{n,13209,"/// AddInitializerToDecl - Adds the initializer Init to the\n/// declaration dcl. If DirectInit is true, this is C++ direct\n/// initialization rather than copy initialization.\nvoid Sema::AddInitializerToDecl(Decl *RealDecl, Expr *Init, bool DirectInit) {\n  // ...\n  if (!VDecl->getType()->isDependentType()) {\n    // ...\n    if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), diag::err_abstract_type_in_decl, AbstractVariableType))"},{n,13643,"/// ActOnInitializerError - Given that there was an error parsing an\n/// initializer for the given declaration, try to at least re-establish\n/// invariants such as whether a variable\'s type is either dependent or\n/// complete.\nvoid Sema::ActOnInitializerError(Decl *D) {\n  // ...\n  if (RequireNonAbstractType(VD->getLocation(), Ty, diag::err_abstract_type_in_decl, AbstractVariableType)) {"},{n,13776,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  // ...\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    // ...\n    case VarDecl::DeclarationOnly:\n      // ...\n      if (!Type->isDependentType() && !Var->isInvalidDecl() && RequireNonAbstractType(Var->getLocation(), Type, diag::err_abstract_type_in_decl, AbstractVariableType))"},{n,13868,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  // ...\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    // ...\n    if (RequireNonAbstractType(Var->getLocation(), Type, diag::err_abstract_type_in_decl, AbstractVariableType)) {"},{n,15350,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  // ...\n  if (!ResultType->isDependentType() && !ResultType->isVoidType() && !FD->isInvalidDecl() && BodyKind != FnBodyKind::Delete && (RequireCompleteType(FD->getLocation(), ResultType, diag::err_func_def_incomplete_result) || RequireNonAbstractType(FD->getLocation(), FD->getReturnType(), diag::err_abstract_type_in_decl, AbstractReturnType)))"},{n,18166,"/// Build a new FieldDecl and check its well-formedness.\n///\n/// This routine builds a new FieldDecl given the fields name, type,\n/// record, etc. \\p PrevDecl should refer to any previous declaration\n/// with the same name and in the same scope as the field to be\n/// created.\n///\n/// \\returns a new FieldDecl.\n///\n/// \\todo The Declarator argument is a hack. It will be removed once\nFieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D) {\n  // ...\n  if (!InvalidDecl && RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl, AbstractFieldType))"},{n,18876,"void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, ArrayRef<Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &Attrs) {\n  // ...\n  for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); i != end; ++i) {\n    // ...\n    if (FDTy->isFunctionType()) {\n    // ...\n    } else if (FDTy->isIncompleteArrayType() && (Record || isa<ObjCContainerDecl>(EnclosingDecl))) {\n    // ...\n    } else if (!FDTy->isDependentType() && RequireCompleteSizedType(FD->getLocation(), FD->getType(), diag::err_field_incomplete_or_sizeless)) {\n    // ...\n    } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {\n      // ...\n      if (isa<ObjCContainerDecl>(EnclosingDecl) && RequireNonAbstractType(FD->getLocation(), FD->getType(), diag::err_abstract_type_in_decl, AbstractIvarType)) {"},{r,6098,"#include \"clang/AST/TypeLocNodes.def\"\n  // ...\n  CheckPolymorphic(PointerTypeLoc) CheckPolymorphic(ReferenceTypeLoc) CheckPolymorphic(MemberPointerTypeLoc) CheckPolymorphic(BlockPointerTypeLoc) CheckPolymorphic(AtomicTypeLoc)\n    // ...\n    // It matched; do some magic.\n    // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.\n    if (Sel == Sema::AbstractArrayType) {\n    // ...\n    } else {\n      Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl) << Sel << T << TL.getSourceRange();"},{r,16661,"/// Perform semantic analysis for the variable declaration that\n/// occurs within a C++ catch clause, returning the newly-created\n/// variable.\nVarDecl *Sema::BuildExceptionDeclaration(Scope *S, TypeSourceInfo *TInfo, SourceLocation StartLoc, SourceLocation Loc, IdentifierInfo *Name) {\n  // ...\n  if (!Invalid && !ExDeclType->isDependentType() && RequireNonAbstractType(Loc, ExDeclType, diag::err_abstract_type_in_decl, AbstractVariableType))"},{P,1326,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // ...\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    // ...\n    if (!Ivar) {\n      // ...\n      if (RequireNonAbstractType(PropertyIvarLoc, PropertyIvarType, diag::err_abstract_type_in_decl, AbstractSynthesizedIvarType)) {"}},

[h]={{U,1568,"Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{U,1587,"/// Perform access-control checking on a previously-unresolved member\n/// access which has now been resolved to a member.\nSema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{U,1741,"/// Checks access to an overloaded operator new or delete.\nSema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair Found, bool Diagnose) {\n  // ...\n  if (Diagnose)\n    Entity.setDiag(diag::err_access) << PlacementRange;"},{U,1790,"Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, const SourceRange &Range, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << ObjectExpr->getSourceRange() << Range;"},{U,1863,"Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << Ovl->getSourceRange();"},{U,1920,"/// Checks access to all the declarations in the given result set.\nvoid Sema::CheckLookupAccess(const LookupResult &R) {\n  // ...\n  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {\n    if (I.getAccess() != AS_public) {\n      // ...\n      Entity.setDiag(diag::err_access);"}},

[b]={"80f00ff95d3b",1305054494,"Re-do R131114 without breaking code.\n\nI\'ve edited one diagnostic which would print \"copy constructor...","Re-do R131114 without breaking code.\n\nI\'ve edited one diagnostic which would print \"copy constructor\" for copy\nconstructors and \"constructor\" for any other constructor. If anyone is\nextremely enamored with this, it can be reinstated with a simple boolean\nflag rather than calling getSpecialMember, which is inappropriate.\n\nllvm-svn: 131143"},

[h]={{U,1660,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  // ...\n  case InitializedEntity::EK_Base:\n    PD = PDiag(diag::err_access_base_ctor);"}},

[h]={{U,1655,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  // ...\n  default:\n    PD = PDiag(IsCopyBindingRefToTemp ? diag::ext_rvalue_to_reference_access_ctor : diag::err_access_ctor);"}},

[b]={"f026b600992d",1371089537,"In C++11, promote access declaration diagnostic from warning to error. There\ndoesn\'t seem to be any ...","In C++11, promote access declaration diagnostic from warning to error. There\ndoesn\'t seem to be any value in even adding a -W flag for this.\n\nllvm-svn: 183882"},

[h]={{r,12068,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  // ...\n  // Warn about access declarations.\n  if (UsingLoc.isInvalid()) {\n    Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11 ? diag::err_access_decl : diag::warn_access_decl_deprecated) << FixItHint::CreateInsertion(SS.getRange().getBegin(), \"using \");"}},

[b]={"fa7781384ebb",1296575411,"Implement access checking for the \"delete\" operator. Fixes PR9050,\nfrom Alex Miller!\n\nllvm-svn: 1246...","Implement access checking for the \"delete\" operator. Fixes PR9050,\nfrom Alex Miller!\n\nllvm-svn: 124663"},

[h]={{t,3775,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  // ...\n  if (!Ex.get()->isTypeDependent()) {\n    // ...\n    if (PointeeRD) {\n      if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {\n        CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, PDiag(diag::err_access_dtor) << PointeeElem);"}},

[h]={{r,5847,"void Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl) {\n  // ...\n  // Bases.\n  for (const auto &Base : ClassDecl->bases()) {\n    // ...\n    CheckDestructorAccess(Base.getBeginLoc(), Dtor, PDiag(diag::err_access_dtor_base) << Base.getType() << Base.getSourceRange(), Context.getTypeDeclType(ClassDecl));"}},

[b]={"442612c2853f",1278542113,"Do not use CXXZeroValueInitExpr for class types. Instead, use\nCXXConstructExpr/CXXTemporaryObjectExp...","Do not use CXXZeroValueInitExpr for class types. Instead, use\nCXXConstructExpr/CXXTemporaryObjectExpr/CXXNewExpr as\nappropriate. Fixes PR7556, and provides a slide codegen improvement\nwhen copy-initializing a POD class type from a value-initialized\ntemporary. Previously, we weren\'t eliding the copy.\n\nllvm-svn: 107827"},

[h]={{t,1033,"/// CheckCXXThrowOperand - Validate the operand of a throw.\nbool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ExceptionObjectTy, Expr *E) {\n  // ...\n  // If the class has a destructor, we must be able to call it.\n  if (!RD->hasIrrelevantDestructor()) {\n    if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {\n      // ...\n      CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_exception) << Ty);"}},

[h]={{r,5797,"void Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl) {\n  // ...\n  // Non-static data members.\n  for (auto *Field : ClassDecl->fields()) {\n    // ...\n    CheckDestructorAccess(Field->getLocation(), Dtor, PDiag(diag::err_access_dtor_field) << Field->getDeclName() << FieldType);"}},

[b]={"527786ea3a6a",1274322262,"Various small fixes for construction/destruction of Objective-C++\ninstance variables:\n  - Use isReco...","Various small fixes for construction/destruction of Objective-C++\ninstance variables:\n  - Use isRecordType() rather than isa<RecordType>(), so that we see\n  through typedefs in ivar types.\n  - Mark the destructor as referenced\n  - Perform C++ access control on the destructor\n\nllvm-svn: 104206"},

[h]={{r,18491,"/// SetIvarInitializers - This routine builds initialization ASTs for the\n/// Objective-C implementation whose ivars need be initialized.\nvoid Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {\n  // ...\n  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {\n    // ...\n    for (unsigned i = 0; i < ivars.size(); i++) {\n      // ...\n      // Be sure that the destructor is accessible and is marked as referenced.\n      if (const RecordType *RecordTy = Context.getBaseElementType(Field->getType())->getAs<RecordType>()) {\n        // ...\n        if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {\n          // ...\n          CheckDestructorAccess(Field->getLocation(), Destructor, PDiag(diag::err_access_dtor_ivar) << Context.getBaseElementType(Field->getType()));"}},

[b]={"8e36d53e34be",1270600906,"Check access for the implicit calls to destructors that occur when we\nhave a temporary object in C++...","Check access for the implicit calls to destructors that occur when we\nhave a temporary object in C++.\n\nAlso fix a tag mismatch that Doug noticed.\n\nllvm-svn: 100593"},

[h]={{t,7334,"ExprResult Sema::MaybeBindToTemporary(Expr *E) {\n  // ...\n  if (Destructor) {\n    // ...\n    CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << E->getType());"},{t,7505,"/// Process the expression contained within a decltype. For such expressions,\n/// certain semantic checks on temporaries are delayed until this point, and\n/// are omitted for the \'topmost\' call in the decltype expression. If the\n/// topmost call bound a temporary, strip that temporary off the expression.\nExprResult Sema::ActOnDecltypeExpression(Expr *E) {\n  // ...\n  // Now all relevant types are complete, check the destructors are accessible\n  // and non-deleted, and annotate them on the temporaries.\n  for (unsigned I = 0, N = ExprEvalContexts.back().DelayedDecltypeBinds.size(); I != N; ++I) {\n    // ...\n    CheckDestructorAccess(Bind->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << Bind->getType());"},{D,1932,"/// Check if the type of a class element has an accessible destructor, and marks\n/// it referenced. Returns true if we shouldn\'t form a reference to the\n/// destructor.\n///\n/// Aggregate initialization requires a class element\'s destructor be\n/// accessible per 11.6.1 [dcl.init.aggr]:\n///\n/// The destructor for each element of class type is potentially invoked\n/// (15.4 [class.dtor]) from the context where the aggregate initialization\n/// occurs.\nstatic bool checkDestructorReference(QualType ElementType, SourceLocation Loc, Sema &SemaRef) {\n  // ...\n  SemaRef.CheckDestructorAccess(Loc, Destructor, SemaRef.PDiag(diag::err_access_dtor_temp) << ElementType);"},{D,8929,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  // ...\n  for (step_iterator Step = step_begin(), StepEnd = step_end(); Step != StepEnd; ++Step) {\n    // ...\n    case SK_UserConversion: {\n      // ...\n      if (shouldBindAsTemporary(Entity))\n      // ...\n      else if (CreatedObject && shouldDestroyEntity(Entity)) {\n        // ...\n        if (const RecordType *Record = T->getAs<RecordType>()) {\n          // ...\n          S.CheckDestructorAccess(CurInit.get()->getBeginLoc(), Destructor, S.PDiag(diag::err_access_dtor_temp) << T);"}},

[h]={{r,15869,"void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {\n  // ...\n  // If this is an array, we\'ll require the destructor during initialization, so\n  // we can skip over this. We still want to emit exit-time destructor warnings\n  // though.\n  if (!VD->getType()->isArrayType()) {\n    // ...\n    CheckDestructorAccess(VD->getLocation(), Destructor, PDiag(diag::err_access_dtor_var) << VD->getDeclName() << VD->getType());"}},

[h]={{r,5885,"void Sema::MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {\n  // Virtual bases.\n  for (const auto &VBase : ClassDecl->vbases()) {\n    // ...\n    if (CheckDestructorAccess(ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), Context.getTypeDeclType(ClassDecl)) == AR_accessible) {"},{r,5891,"void Sema::MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {\n  // Virtual bases.\n  for (const auto &VBase : ClassDecl->vbases()) {\n    // ...\n    if (CheckDestructorAccess(ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), Context.getTypeDeclType(ClassDecl)) == AR_accessible) {\n      CheckDerivedToBaseConversion(Context.getTypeDeclType(ClassDecl), VBase.getType(), diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(), SourceRange(), DeclarationName(), nullptr);"}},

[b]={"80f00ff95d3b",1305054494,"Re-do R131114 without breaking code.\n\nI\'ve edited one diagnostic which would print \"copy constructor...","Re-do R131114 without breaking code.\n\nI\'ve edited one diagnostic which would print \"copy constructor\" for copy\nconstructors and \"constructor\" for any other constructor. If anyone is\nextremely enamored with this, it can be reinstated with a simple boolean\nflag rather than calling getSpecialMember, which is inappropriate.\n\nllvm-svn: 131143"},

[h]={{U,1668,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  // ...\n  case InitializedEntity::EK_Member:\n  case InitializedEntity::EK_ParenAggInitMember: {\n    // ...\n    PD = PDiag(diag::err_access_field_ctor);"}},

[b]={"a0a96895501e",1344568535,"Check access to friend declarations.  There\'s a number of different\nthings going on here that were p...","Check access to friend declarations.  There\'s a number of different\nthings going on here that were problematic:\n  - We were missing the actual access check, or rather, it was suppressed\n    on account of being a redeclaration lookup.\n  - The access check would naturally happen during delay, which isn\'t\n    appropriate in this case.\n  - We weren\'t actually emitting dependent diagnostics associated with\n    class templates, which was unfortunate.\n  - Access was being propagated incorrectly for friend method declarations\n    that couldn\'t be matched at parse-time.\n\nllvm-svn: 161652"},

[h]={{U,1836,"/// Checks access to the target of a friend declaration.\nSema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) {\n  // ...\n  entity.setDiag(diag::err_access_friend_function) << (method->getQualifier() ? method->getQualifierLoc().getSourceRange() : method->getNameInfo().getSourceRange());"}},

[b]={"19666fb1aa7d",1329325046,"Introduce a new initialization entity for lambda captures, and\nspecialize location information and d...","Introduce a new initialization entity for lambda captures, and\nspecialize location information and diagnostics for this entity.\n\nllvm-svn: 150588"},

[h]={{U,1675,"/// Checks access to a constructor.\nSema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, bool IsCopyBindingRefToTemp) {\n  // ...\n  case InitializedEntity::EK_LambdaCapture: {\n    // ...\n    PD = PDiag(diag::err_access_lambda_capture);"}},

[g]=v,

[b]={"db632ac004ae",1348558359,"Fix for r163013 regression and further __interface enhancement.\nPatch by Andy Gibbs!\n\nllvm-svn: 1645...","Fix for r163013 regression and further __interface enhancement.\nPatch by Andy Gibbs!\n\nllvm-svn: 164590"},

[h]={{I,3403,"Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(AccessSpecifier &AS, ParsedAttributes &AccessAttrs, DeclSpec::TST TagType, Decl *TagDecl) {\n  // ...\n  case tok::kw_public:\n  case tok::kw_protected: {\n    // ...\n    // The Microsoft extension __interface does not permit non-public\n    // access specifiers.\n    if (TagType == DeclSpec::TST_interface && AS != AS_public) {\n      Diag(ASLoc, diag::err_access_specifier_interface) << (AS == AS_protected);"}},

[b]={"b257e4fff8a9",1247096032,"Implement the simple form of overload resolution used when taking the\naddress of an overloaded funct...","Implement the simple form of overload resolution used when taking the\naddress of an overloaded function (which may involve both functions\nand function templates). \n\nllvm-svn: 75069"},

[h]={{R,12563,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  // ...\n  void EliminateAllExceptMostSpecializedTemplate() {\n    // ...\n    UnresolvedSetIterator Result = S.getMostSpecialized(MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates, SourceExpr->getBeginLoc(), S.PDiag(), S.PDiag(diag::err_addr_ovl_ambiguous) << Matches[0].second->getDeclName(), S.PDiag(diag::note_ovl_candidate) << (unsigned)oc_function << (unsigned)ocs_described_template, Complain, TargetFunctionType);"},{R,12651,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  // ...\n  void ComplainMultipleMatchesFound() const {\n    // ...\n    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous) << OvlExpr->getName() << OvlExpr->getSourceRange();"},{R,12905,"/// Given an expression that refers to an overloaded function, try to\n/// resolve that overloaded function expression down to a single function.\n///\n/// This routine can only resolve template-ids that refer to a single function\n/// template, where that template-id refers to a single template whose template\n/// arguments are either provided by the template-id or have defaults,\n/// as described in C++0x [temp.arg.explicit]p3.\n///\n/// If no template-ids are found, no diagnostics are emitted and NULL is\n/// returned.\nFunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl, bool Complain, DeclAccessPair *FoundResult, TemplateSpecCandidateSet *FailedTSC) {\n  // ...\n  for (UnresolvedSetIterator I = ovl->decls_begin(), E = ovl->decls_end(); I != E; ++I) {\n    // ...\n    // Multiple matches; we can\'t resolve to a single declaration.\n    if (Matched) {\n      if (Complain) {\n        Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous) << ovl->getName();"}},

[b]={"24d189484b44",1282690359,"When trying to resolve the address of an overloaded expression,\nonly form pointers-to-member if the ...","When trying to resolve the address of an overloaded expression,\nonly form pointers-to-member if the expression has the appropriate\nform.  This avoids assertions later on on invalid code, but also\nallows us to properly resolve mixed-staticity overloads.\n\nllvm-svn: 111987"},

[h]={{R,12630,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  // ...\n  void ComplainIsInvalidFormOfPointerToMemberFunction() const {\n    // ...\n    S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier) << TargetType << OvlExpr->getSourceRange();"}},

[b]={"064fdb2fe844",1271286681,"Always diagnose and complain about problems in\nResolveAddressOfOverloadedFunction when asked to comp...","Always diagnose and complain about problems in\nResolveAddressOfOverloadedFunction when asked to complain. Previously,\nwe had some weird handshake where ResolveAddressOfOverloadedFunction\nexpected its caller to handle some of the diagnostics but not others,\nand yet there was no way for the caller to know which case we were\nin. Eliminate this madness, fixing <rdar://problem/7765884>.\n\nllvm-svn: 101312"},

[h]={{R,12599,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  // ...\n  void ComplainNoMatchesFound() const {\n    // ...\n    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable) << OvlExpr->getName() << TargetFunctionType << OvlExpr->getSourceRange();"}},

[b]={"064fdb2fe844",1271286681,"Always diagnose and complain about problems in\nResolveAddressOfOverloadedFunction when asked to comp...","Always diagnose and complain about problems in\nResolveAddressOfOverloadedFunction when asked to complain. Previously,\nwe had some weird handshake where ResolveAddressOfOverloadedFunction\nexpected its caller to handle some of the diagnostics but not others,\nand yet there was no way for the caller to know which case we were\nin. Eliminate this madness, fixing <rdar://problem/7765884>.\n\nllvm-svn: 101312"},

[h]={{R,12645,"// A helper class to help with address of function resolution\n// - allows us to avoid passing around all those ugly parameters\nclass AddressOfFunctionResolver {\n  // ...\n  void ComplainOfInvalidConversion() const { S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref) << OvlExpr->getName() << TargetType; }"}}

[b]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang.\n\n`pass_object_size` is our way of enabling `__builtin...","Add the `pass_object_size` attribute to clang.\n\n`pass_object_size` is our way of enabling `__builtin_object_size` to\nproduce high quality results without requiring inlining to happen\neverywhere.\n\nA link to the design doc for this attribute is available at the\nDifferential review link below.\n\nDifferential Revision: http://reviews.llvm.org/D13263\n\nllvm-svn: 254554"},

[h]={{R,10609,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  // ...\n  if (Complain) {\n    // ...\n    if (InOverloadResolution)\n    // ...\n    else\n      S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params) << FD << ParamNo;"}},

[g]=v,

[b]={"9ba479bd2c2c",1298063799,"fix rdar://9024687, a crash on invalid that we used to silently ignore.\n\nllvm-svn: 125962","fix rdar://9024687, a crash on invalid that we used to silently ignore.\n\nllvm-svn: 125962"},

[h]={{Cb,1460,"#include \"clang/Basic/TransformTypeTraits.def\"\n  // ...\n  case tok::ampamp: { // unary-expression: \'&&\' identifier\n    // ...\n    if (getCurScope()->getFnParent() == nullptr)\n      return ExprError(Diag(Tok, diag::err_address_of_label_outside_fn));"}},

[b]={"12e3a8af81da",1544029342,"[OpenCL] Diagnose conflicting address spaces in templates.\n\nAdded new diagnostic when templates are ...","[OpenCL] Diagnose conflicting address spaces in templates.\n\nAdded new diagnostic when templates are instantiated with\ndifferent address space from the one provided in its definition.\n\nThis also prevents deducing generic address space in pointer\ntype of templates to allow giving them concrete address space\nduring instantiation.\n\nDifferential Revision: https://reviews.llvm.org/D55127\n\nllvm-svn: 348382"},

[b]={"39d1a0973db9",1302896780,"Forbid the use of C++ new/delete to allocate/free objects within an\naddress space. I could see that ...","Forbid the use of C++ new/delete to allocate/free objects within an\naddress space. I could see that this functionality would be useful,\nbut not in its current form (where the address space is ignored):\nrather, we\'d want to encode the address space into the parameter list\npassed to operator new/operator delete somehow, which would require a\nbunch more semantic analysis.\n\nllvm-svn: 129593"},

[h]={{t,3677,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  // ...\n  if (!Ex.get()->isTypeDependent()) {\n    // ...\n    if (Pointee.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n      return Diag(Ex.get()->getBeginLoc(), diag::err_address_space_qualified_delete) << Pointee.getUnqualifiedType() << Pointee.getQualifiers().getAddressSpaceAttributePrintValue();"}},

[b]={"39d1a0973db9",1302896780,"Forbid the use of C++ new/delete to allocate/free objects within an\naddress space. I could see that ...","Forbid the use of C++ new/delete to allocate/free objects within an\naddress space. I could see that this functionality would be useful,\nbut not in its current form (where the address space is ignored):\nrather, we\'d want to encode the address space into the parameter list\npassed to operator new/operator delete somehow, which would require a\nbunch more semantic analysis.\n\nllvm-svn: 129593"},

[h]={{t,2475,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  // C++ 5.3.4p1: \"[The] type shall be a complete object type, but not an\n  //  abstract class type or array thereof.\n  if (AllocType->isFunctionType())\n  // ...\n  else if (AllocType->isReferenceType())\n  // ...\n  else if (!AllocType->isDependentType() && RequireCompleteSizedType(Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))\n  // ...\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))\n  // ...\n  else if (AllocType->isVariablyModifiedType())\n  // ...\n  else if (AllocType.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n    return Diag(Loc, diag::err_address_space_qualified_new) << AllocType.getUnqualifiedType() << AllocType.getQualifiers().getAddressSpaceAttributePrintValue();"}},

[b]={"349636d2bfc3",1575555459,"Implement VectorType conditional operator GNU extension.\n\nGCC supports the conditional operator on V...","Implement VectorType conditional operator GNU extension.\n\nGCC supports the conditional operator on VectorTypes that acts as a\n\'select\' in C++ mode. This patch implements the support. Types are\nconverted as closely to GCC\'s behavior as possible, though in a few\nplaces consistency with our existing vector type support was preferred.\n\nNote that this implementation is different from the OpenCL version in a\nnumber of ways, so it unfortunately required a different implementation.\n\nFirst, the SEMA rules and promotion rules are significantly different.\n\nSecondly, GCC implements COND[i] != 0 ? LHS[i] : RHS[i] (where i is in\nthe range 0- VectorSize, for each element).  In OpenCL, the condition is\nCOND[i] < 0 ? LHS[i]: RHS[i].\n\nIn the process of implementing this, it was also required to make the\nexpression COND ? LHS : RHS type dependent if COND is type dependent,\nsince the type is now dependent on the condition.  For example:\n\n    T ? 1 : 2;\n\nIs not typically type dependent, since the result can be deduced from\nthe operands.  HOWEVER, if T is a VectorType now, it could change this\nto a \'select\' (basically a swizzle with a non-constant mask) with the 1\nand 2 being promoted to vectors themselves.\n\nWhile this is a change, it is NOT a standards incompatible change. Based\non my (and D. Gregor\'s, at the time of writing the code) reading of the\nstandard, the expression is supposed to be type dependent if ANY\nsub-expression is type dependent.\n\nDifferential Revision: https://reviews.llvm.org/D71463"},

[h]={{R,10587,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  // ...\n  if (FD->getTrailingRequiresClause()) {\n    // ...\n    if (!Satisfaction.IsSatisfied) {\n      if (Complain) {\n        if (InOverloadResolution) {\n        // ...\n        } else\n          S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied) << FD;"}}

[b]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang.\n\n`pass_object_size` is our way of enabling `__builtin...","Add the `pass_object_size` attribute to clang.\n\n`pass_object_size` is our way of enabling `__builtin_object_size` to\nproduce high quality results without requiring inlining to happen\neverywhere.\n\nA link to the design doc for this attribute is available at the\nDifferential review link below.\n\nDifferential Revision: http://reviews.llvm.org/D13263\n\nllvm-svn: 254554"},

[h]={{R,10563,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  if (!isFunctionAlwaysEnabled(S.Context, FD)) {\n    if (Complain) {\n      if (InOverloadResolution)\n      // ...\n      else\n        S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;"}},

[b]={Tb,1615397021,Ub,Vb},

[b]={"0687578728ea",1610286626,"[C++20][Modules][HU 2/5] Support searching Header Units in user or system search paths.\n\nThis is sup...","[C++20][Modules][HU 2/5] Support searching Header Units in user or system search paths.\n\nThis is support for the user-facing options to create importable header units\nfrom headers in the user or system search paths (or to be given an absolute path).\n\nThis means that an incomplete header path will be passed by the driver and the\nlookup carried out using the search paths present when the front end is run.\n\nTo support this, we introduce file fypes for c++-{user,system,header-unit}-header.\nThese terms are the same as the ones used by GCC, to minimise the differences for\ntooling (and users).\n\nThe preprocessor checks for headers before issuing a warning for\n\"#pragma once\" in a header build.  We ensure that the importable header units\nare recognised as headers in order to avoid such warnings.\n\nDifferential Revision: https://reviews.llvm.org/D121096"},

[h]={{O,1892,"#include \"clang/Driver/Options.inc\"\n  // ...\n  if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {\n    if (T.isOSAIX()) {\n      // ...\n      if (Name != \"global-dynamic\" && Name != \"local-exec\")\n        Diags.Report(diag::err_aix_unsupported_tls_model) << Name;"}},

[b]={"d53ffa0a70d8",1382477943,"Treat aliases as definitions.\n\nThis fixes pr17639.\n\nBefore this patch clang would consider\n\nvoid foo...","Treat aliases as definitions.\n\nThis fixes pr17639.\n\nBefore this patch clang would consider\n\nvoid foo(void) __attribute((alias(\"__foo\")));\n\na declaration. It now correctly handles it as a definition.\n\nInitial patch by Alp Toker. I added support for variables.\n\nllvm-svn: 193200"},

[h]={{n,3041,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  // ...\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    // ...\n    if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {\n      if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {\n      // ...\n      } else {\n        // ...\n        unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == VarDecl::TentativeDefinition ? diag::err_alias_after_tentative : diag::err_redefinition;"}},

[g]=v,

[b]={"dda56e4b4a9c",1302877477,"Support for C++11 (non-template) alias declarations.\n\nllvm-svn: 129567","Support for C++11 (non-template) alias declarations.\n\nllvm-svn: 129567"},

[h]={{I,905,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // ...\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n    Diag(D.Name.StartLocation, diag::err_alias_declaration_not_identifier);"},{I,910,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // ...\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n  // ...\n  } else if (D.TypenameLoc.isValid())\n    Diag(D.TypenameLoc, diag::err_alias_declaration_not_identifier) << FixItHint::CreateRemoval(SourceRange(D.TypenameLoc, D.SS.isNotEmpty() ? D.SS.getEndLoc() : D.TypenameLoc));"},{I,915,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // ...\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n  // ...\n  } else if (D.TypenameLoc.isValid())\n  // ...\n  else if (D.SS.isNotEmpty())\n    Diag(D.SS.getBeginLoc(), diag::err_alias_declaration_not_identifier) << FixItHint::CreateRemoval(D.SS.getRange());"}},

[g]=v,

[b]={"22a250cd5d8e",1482120533,"[c++1z] P0195R2: Support pack-expansion of using-declarations.\n\nThis change introduces UsingPackDecl...","[c++1z] P0195R2: Support pack-expansion of using-declarations.\n\nThis change introduces UsingPackDecl as a marker for the set of UsingDecls\nproduced by pack expansion of a single (unresolved) using declaration. This is\nnot strictly necessary (we just need to be able to map from the original using\ndeclaration to its expansions somehow), but it\'s useful to maintain the\ninvariant that each declaration reference instantiates to refer to one\ndeclaration.\n\nllvm-svn: 290080"},

[h]={{I,918,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // ...\n  if (D.EllipsisLoc.isValid())\n    Diag(D.EllipsisLoc, diag::err_alias_declaration_pack_expansion) << FixItHint::CreateRemoval(SourceRange(D.EllipsisLoc));"}}

[g]=v,

[b]={"3f1b5d077b7e",1304632627,"Implement support for C++0x alias templates.\n\nllvm-svn: 130953","Implement support for C++0x alias templates.\n\nllvm-svn: 130953"},

[h]={{I,897,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // ...\n  if (SpecKind != -1) {\n    // ...\n    Diag(Range.getBegin(), diag::err_alias_declaration_specialization) << SpecKind << Range;"}},

[b]={"2dc814664385",1421658028,"Sema: Variable definitions cannot be __attribute__((alias))\n\nThings that are OK:\n  extern int var1 _...","Sema: Variable definitions cannot be __attribute__((alias))\n\nThings that are OK:\n  extern int var1 __attribute((alias(\"v1\")));\n  static int var2 __attribute((alias(\"v2\")));\n\nThings that are not OK:\n  int var3 __attribute((alias(\"v3\")));\n  extern int var4 __attribute((alias(\"v4\"))) = 4;\n\nWe choose to accpet:\n  struct S { static int var5 __attribute((alias(\"v5\"))); };\n\n  This code causes assertion failues in GCC 4.8 and ICC 13.0.1, we have\n  no reason to reject it.\n\nThis partially fixes PR22217.\n\nllvm-svn: 226436"},

[h]={{n,6968,"static void checkAttributesAfterMerging(Sema &S, NamedDecl &ND) {\n  // ...\n  if (auto *VD = dyn_cast<VarDecl>(&ND)) {\n    if (VD->hasInit()) {\n      if (const auto *Attr = VD->getAttr<AliasAttr>()) {\n        // ...\n        S.Diag(Attr->getLocation(), diag::err_alias_is_definition) << VD << 0;"},{n,15265,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  // ...\n  // Check for defining attributes before the check for redefinition.\n  if (const auto *Attr = FD->getAttr<AliasAttr>()) {\n    Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 0;"},{n,15270,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  // ...\n  if (const auto *Attr = FD->getAttr<IFuncAttr>()) {\n    Diag(Attr->getLocation(), diag::err_alias_is_definition) << FD << 1;"},{l,1980,"static void handleIFuncAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // ...\n  if (FD->isThisDeclarationADefinition()) {\n    S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 1;"},{l,2003,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // ...\n  // Aliases should be on declarations, not definitions.\n  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n    if (FD->isThisDeclarationADefinition()) {\n      S.Diag(AL.getLoc(), diag::err_alias_is_definition) << FD << 0;"},{l,2009,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // ...\n  // Aliases should be on declarations, not definitions.\n  if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n  // ...\n  } else {\n    // ...\n    if (VD->isThisDeclarationADefinition() && VD->isExternallyVisible()) {\n      S.Diag(AL.getLoc(), diag::err_alias_is_definition) << VD << 0;"},{l,7662,"static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // ...\n  if (FD->isThisDeclarationADefinition()) {\n    S.Diag(D->getLocation(), diag::err_alias_is_definition) << FD << 0;"}},

[b]={"0017c5fa92ad",1291735403,"Fix PR8720 by printing an error message with a substring that the gcc testsuite searches for.\n\nllvm-...","Fix PR8720 by printing an error message with a substring that the gcc testsuite searches for.\n\nllvm-svn: 121137"},

[b]={"a8f0254bc1a4",1453584490,"[CUDA] Reject the alias attribute in CUDA device code.\n\nSummary: CUDA (well, strictly speaking, NVPT...","[CUDA] Reject the alias attribute in CUDA device code.\n\nSummary: CUDA (well, strictly speaking, NVPTX) doesn\'t support aliases.\n\nReviewers: echristo\n\nSubscribers: cfe-commits, jhen, tra\n\nDifferential Revision: http://reviews.llvm.org/D16502\n\nllvm-svn: 258641"},

[b]={"3f1b5d077b7e",1304632627,"Implement support for C++0x alias templates.\n\nllvm-svn: 130953","Implement support for C++0x alias templates.\n\nllvm-svn: 130953"},

[h]={{r,13299,"Decl *Sema::ActOnAliasDeclaration(Scope *S, AccessSpecifier AS, MultiTemplateParamsArg TemplateParamLists, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec) {\n  // ...\n  if (TemplateParamLists.size()) {\n    // ...\n    if (TemplateParamLists.size() != 1) {\n      Diag(UsingLoc, diag::err_alias_template_extra_headers) << SourceRange(TemplateParamLists[1]->getTemplateLoc(), TemplateParamLists[TemplateParamLists.size() - 1]->getRAngleLoc());"}},

[b]={"0fad0d772433",1382449866,"This patch causes clang to reject alias attributes that point to undefined\nnames. For example, with ...","This patch causes clang to reject alias attributes that point to undefined\nnames. For example, with this patch we now reject\n\nvoid f1(void) __attribute__((alias(\"g1\")));\n\nThis patch is implemented in CodeGen. It is quiet a bit simpler and more\ncompatible with gcc than implementing it in Sema. The downside is that the\nerrors only fire during -emit-llvm.\n\nllvm-svn: 193161"},

[b]={"1b0d24e03abf",1412284885,"Initial support for the align_value attribute\n\nThis adds support for the align_value attribute. This...","Initial support for the align_value attribute\n\nThis adds support for the align_value attribute. This attribute is supported by\nIntel\'s compiler (versions 14.0+), and several of my HPC users have requested\nsupport in Clang. It specifies an alignment assumption on the values to which a\npointer points, and is used by numerical libraries to encourage efficient\ngeneration of vector code.\n\nOf course, we already have an aligned attribute that can specify enhanced\nalignment for a type, so why is this additional attribute important? The\nproblem is that if you want to specify that an input array of T is, say,\n64-byte aligned, you could try this:\n\n  typedef double aligned_double attribute((aligned(64)));\n  void foo(aligned_double *P) {\n    double x = P[0]; // This is fine.\n    double y = P[1]; // What alignment did those doubles have again?\n  }\n\nthe access here to P[1] causes problems. P was specified as a pointer to type\naligned_double, and any object of type aligned_double must be 64-byte aligned.\nBut if P[0] is 64-byte aligned, then P[1] cannot be, and this access causes\nundefined behavior. Getting round this problem requires a lot of awkward\ncasting and hand-unrolling of loops, all of which is bad.\n\nWith the align_value attribute, we can accomplish what we\'d like in a well\ndefined way:\n\n  typedef double *aligned_double_ptr attribute((align_value(64)));\n  void foo(aligned_double_ptr P) {\n    double x = P[0]; // This is fine.\n    double y = P[1]; // This is fine too.\n  }\n\nThis attribute does not create a new type (and so it not part of the type\nsystem), and so will only \"propagate\" through templates, auto, etc. by\noptimizer deduction after inlining. This seems consistent with Intel\'s\nimplementation (thanks to Alexey for confirming the various Intel-compiler\nbehaviors).\n\nAs a final note, I would have chosen to call this aligned_value, not\nalign_value, for better naming consistency with the aligned attribute, but I\nthink it would be more useful to users to adopt Intel\'s name.\n\nllvm-svn: 218910"},

[b]={"1dba27cd4942",1359450129,"Implement C++11 [dcl.align]p1 and C11 6.7.5/2 rules for alignas and _Alignas.\n\nllvm-svn: 173779","Implement C++11 [dcl.align]p1 and C11 6.7.5/2 rules for alignas and _Alignas.\n\nllvm-svn: 173779"},

[b]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of\nthe normal attribute-...","Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of\nthe normal attribute-merging path, because we can\'t merge alignment attributes\nwithout knowing the complete set of alignment attributes which apply to a\nparticular declaration.\n\nllvm-svn: 175861"},

[h]={{n,2841,"/// Merge alignment attributes from \\p Old to \\p New, taking into account the\n/// special semantics of C11\'s _Alignas specifier and C++11\'s alignas attribute.\n///\n/// \\return \\c true if any attributes were added to \\p New.\nstatic bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {\n  // ...\n  if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {\n    // ...\n    if (OldAlign != NewAlign) {\n      S.Diag(NewAlignasAttr->getLocation(), diag::err_alignas_mismatch) << (unsigned)S.Context.toCharUnitsFromBits(OldAlign).getQuantity() << (unsigned)S.Context.toCharUnitsFromBits(NewAlign).getQuantity();"}},

[b]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of\nthe normal attribute-...","Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of\nthe normal attribute-merging path, because we can\'t merge alignment attributes\nwithout knowing the complete set of alignment attributes which apply to a\nparticular declaration.\n\nllvm-svn: 175861"},

[h]={{n,2857,"/// Merge alignment attributes from \\p Old to \\p New, taking into account the\n/// special semantics of C11\'s _Alignas specifier and C++11\'s alignas attribute.\n///\n/// \\return \\c true if any attributes were added to \\p New.\nstatic bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {\n  // ...\n  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {\n    // ...\n    S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) << OldAlignasAttr;"},{n,3085,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  // ...\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    // ...\n    if (isa<C11NoReturnAttr>(NewAttribute)) {\n    // ...\n    } else if (isa<UuidAttr>(NewAttribute)) {\n    // ...\n    } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {\n      if (AA->isAlignas()) {\n        // ...\n        S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) << AA;"}},

[b]={"848e1f19605a",1359706328,"Implement [dcl.align]p5 and C11 6.7.5/4: alignas cannot underalign.\nAlso support alignas(0), which C...","Implement [dcl.align]p5 and C11 6.7.5/4: alignas cannot underalign.\nAlso support alignas(0), which C++11 and C11 require us to ignore.\n\nllvm-svn: 174157"},

[b]={"e5015abf185b",1533337957,"[Preprocessor] Allow libc++ to detect when aligned allocation is unavailable.\n\nLibc++ needs to know ...","[Preprocessor] Allow libc++ to detect when aligned allocation is unavailable.\n\nLibc++ needs to know when aligned allocation is supported by clang, but is\notherwise unavailable at link time. Otherwise, libc++ will incorrectly end up\ngenerating calls to `__builtin_operator_new`/`__builtin_operator_delete` with\nalignment arguments.\n\nThis patch implements the following changes:\n\n* The `__cpp_aligned_new` feature test macro to no longer be defined when\n  aligned allocation is otherwise enabled but unavailable.\n\n* The Darwin driver no longer passes `-faligned-alloc-unavailable` when the\n  user manually specifies `-faligned-allocation` or `-fno-aligned-allocation`.\n\n* Instead of a warning Clang now generates a hard error when an aligned\n  allocation or deallocation function is referenced but unavailable.\n\nPatch by Eric Fiselier.\n\nReviewers: rsmith, vsapsai, erik.pilkington, ahatanak, dexonsmith\n\nReviewed By: rsmith\n\nSubscribers: Quuxplusone, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D45015\n\nllvm-svn: 338934"},

[h]={{t,1968,"// Emit a diagnostic if an aligned allocation/deallocation function that is not\n// implemented in the standard library is selected.\nvoid Sema::diagnoseUnavailableAlignedAllocation(const FunctionDecl &FD, SourceLocation Loc) {\n  if (isUnavailableAlignedAllocationFunction(FD)) {\n    // ...\n    Diag(Loc, diag::err_aligned_allocation_unavailable) << IsDelete << FD.getType().getAsString() << OSName << OSVersion.getAsString() << OSVersion.empty();"}},

[b]={"e2b3744890f6",1336171132,"Move Sema::VerifyIntegerConstantExpression() and\nSema::ConvertToIntegralOrEnumerationType() from Par...","Move Sema::VerifyIntegerConstantExpression() and\nSema::ConvertToIntegralOrEnumerationType() from PartialDiagnostics to\nabstract \"diagnoser\" classes. Not much of a win here, but we\'re\n-several PartialDiagnostics.\n\nllvm-svn: 156217"},

[b]={"26a1e0ef760a",1428374229,"[Sema] Don\'t permit dependent alignments on non-dependent typedef-names\n\nA dependent alignment attri...","[Sema] Don\'t permit dependent alignments on non-dependent typedef-names\n\nA dependent alignment attribute (like __attribute__((aligned(...))) or\n__declspec(align(...))) on a non-dependent typedef or using declaration\nposes a considerable challenge: the type is _not_ dependent, the size\n_may_ be dependent if the type is used as an array type, the alignment\n_is_ dependent.\n\nIt is reasonable for a compiler to be able to query the size and\nalignment of a complete type.  Let\'s help that become an invariant.\n\nThis fixes PR22042.\n\nDifferential Revision: http://reviews.llvm.org/D8693\n\nllvm-svn: 234280"},

[b]={"bcc06085a894",1410130694,"Add __builtin_assume and __builtin_assume_aligned using @llvm.assume.\n\nThis makes use of the recentl...","Add __builtin_assume and __builtin_assume_aligned using @llvm.assume.\n\nThis makes use of the recently-added @llvm.assume intrinsic to implement a\n__builtin_assume(bool) intrinsic (to provide additional information to the\noptimizer). This hooks up __assume in MS-compatibility mode to mirror\n__builtin_assume (the semantics have been intentionally kept compatible), and\nimplements GCC\'s __builtin_assume_aligned as assume((p - o) & mask == 0). LLVM\nnow contains special logic to deal with assumptions of this form.\n\nllvm-svn: 217349"},

[h]={{p,339,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n  // ...\n  // We can\'t check validity of alignment if it is value dependent.\n  if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n    // ...\n    if (!AlignValue.isPowerOf2()) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_not_power_of_two);"},{p,8631,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n  // ...\n  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    // ...\n    if (!Result.isPowerOf2())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two) << Arg->getSourceRange();"},{p,8674,"/// Handle __builtin_assume_aligned. This is declared\n/// as (const void*, size_t, ...) and can take one optional constant int arg.\nbool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {\n  // ...\n  // We can\'t check the value of a dependent argument.\n  if (!SecondArg->isValueDependent()) {\n    // ...\n    if (!Result.isPowerOf2())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two) << SecondArg->getSourceRange();"},{l,1711,"void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE) {\n  // ...\n  if (!E->isValueDependent()) {\n    // ...\n    if (!I->isPowerOf2()) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"},{l,4336,"void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {\n  // ...\n  if (!E->isValueDependent()) {\n    // ...\n    if (!Alignment.isPowerOf2()) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"},{l,4494,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n  // ...\n  // C++11 [dcl.align]p2:\n  //  -- if the constant expression evaluates to zero, the alignment\n  //      specifier shall have no effect\n  // C11 6.7.5p6:\n  //  An alignment specification of zero has no effect.\n  if (!(TmpAttr.isAlignas() && !Alignment)) {\n    if (!llvm::isPowerOf2_64(AlignVal)) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"}},

[b]={"5116993f8ea7",1477892268,"Add support for __builtin_alloca_with_align\n\n__builtin_alloca always uses __BIGGEST_ALIGNMENT__ for ...","Add support for __builtin_alloca_with_align\n\n__builtin_alloca always uses __BIGGEST_ALIGNMENT__ for the alignment of\nthe allocation.  __builtin_alloca_with_align allows the programmer to\nspecify the alignment of the allocation.\n\nThis fixes PR30658.\n\nllvm-svn: 285544"},

[h]={{p,334,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n  // ...\n  // We can\'t check validity of alignment if it is value dependent.\n  if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n    // ...\n    if (llvm::APSInt::compareValues(AlignValue, MaxValue) > 0) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_big) << toString(MaxValue, 10);"},{p,8639,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n  // ...\n  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    // ...\n    if (Result > std::numeric_limits<int32_t>::max())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_big) << std::numeric_limits<int32_t>::max() << Arg->getSourceRange();"}},

[b]={"5116993f8ea7",1477892268,"Add support for __builtin_alloca_with_align\n\n__builtin_alloca always uses __BIGGEST_ALIGNMENT__ for ...","Add support for __builtin_alloca_with_align\n\n__builtin_alloca always uses __BIGGEST_ALIGNMENT__ for the alignment of\nthe allocation.  __builtin_alloca_with_align allows the programmer to\nspecify the alignment of the allocation.\n\nThis fixes PR30658.\n\nllvm-svn: 285544"},

[h]={{p,330,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n  // ...\n  // We can\'t check validity of alignment if it is value dependent.\n  if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n    // ...\n    if (AlignValue < 1) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_too_small) << 1;"},{p,8635,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n  // ...\n  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    // ...\n    if (Result < Context.getCharWidth())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_too_small) << (unsigned)Context.getCharWidth() << Arg->getSourceRange();"}},

[b]={"768439eb2e7e",1367826034,"Require the containing type to be complete when we see\n__alignof__ of a field.\n\nThis problem can onl...","Require the containing type to be complete when we see\n__alignof__ of a field.\n\nThis problem can only happen in C++11.\n\nAlso do some petty optimizations.\n\nrdar://13784901\n\nllvm-svn: 181185"},

[h]={{u,4687,"static bool CheckAlignOfExpr(Sema &S, Expr *E, UnaryExprOrTypeTrait ExprKind) {\n  // ...\n  // If it\'s a field, require the containing struct to have a\n  // complete definition so that we can compute the layout.\n  //\n  // This can happen in C++11 onwards, either by naming the member\n  // in a way that is not transformed into a member access expression\n  // (in an unevaluated operand, for instance), or by naming the member\n  // in a trailing-return-type.\n  //\n  // For the record, since __alignof__ on expressions is a GCC\n  // extension, GCC seems to permit this but always gives the\n  // nonsensical answer 0.\n  //\n  // We don\'t really need the layout here --- we could instead just\n  // directly check for all the appropriate alignment-lowing\n  // attributes --- but that would require duplicating a lot of\n  // logic that just isn\'t worth duplicating for such a marginal\n  // use-case.\n  if (FieldDecl *FD = dyn_cast_or_null<FieldDecl>(D)) {\n    // Fast path this check, since we at least know the record has a\n    // definition if we can find a member of it.\n    if (!FD->getParent()->isCompleteDefinition()) {\n      S.Diag(E->getExprLoc(), diag::err_alignof_member_of_incomplete_type) << E->getSourceRange();"}},

[b]={"0d5ca29b7836",1237830550,"It\'s an error to try to allocate an abstract object using new.\n\nllvm-svn: 67542","It\'s an error to try to allocate an abstract object using new.\n\nllvm-svn: 67542"},

[h]={{s,1885,"/// TryStaticImplicitCast - Tests whether a conversion according to C++ 5.2.9p2\n/// is valid:\n///\n///  An expression e can be explicitly converted to a type T using a\n///  @c static_cast if the declaration \"T t(e);\" is well-formed [...].\nTryCastResult TryStaticImplicitCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, Sema::CheckedConversionKind CCK, SourceRange OpRange, unsigned &msg, CastKind &Kind, bool ListInitialization) {\n  if (DestType->isRecordType()) {\n    if (Self.RequireCompleteType(OpRange.getBegin(), DestType, diag::err_bad_cast_incomplete) || Self.RequireNonAbstractType(OpRange.getBegin(), DestType, diag::err_allocation_of_abstract_type)) {"},{t,2468,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  // ...\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))"},{t,4120,"static ExprResult BuildCXXCastArgument(Sema &S, SourceLocation CastLoc, QualType Ty, CastKind Kind, CXXMethodDecl *Method, DeclAccessPair FoundDecl, bool HadMultipleCandidates, Expr *From) {\n  // ...\n  case CK_ConstructorConversion: {\n    // ...\n    if (S.RequireNonAbstractType(CastLoc, Ty, diag::err_allocation_of_abstract_type))"},{D,8719,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  // ...\n  // C++ [class.abstract]p2:\n  //  no objects of an abstract class can be created except as subobjects\n  //  of a class derived from it\n  auto checkAbstractType = [&](QualType T) -> bool {\n    // ...\n    return S.RequireNonAbstractType(Kind.getLocation(), T, diag::err_allocation_of_abstract_type);"}},

[b]={"a96114ed087b",1249840544,"AltiVec-style vector initializer syntax, vec4 a = (vec4)(a, b, c, d);\n\nIn addition to being defined ...","AltiVec-style vector initializer syntax, vec4 a = (vec4)(a, b, c, d);\n\nIn addition to being defined by the AltiVec PIM, this is also the vector\ninitializer syntax used by OpenCL, so that vector literals are compatible\nwith macro arguments.\n\nllvm-svn: 78535"},

[h]={{u,8445,"ExprResult Sema::ActOnCastExpr(Scope *S, SourceLocation LParenLoc, Declarator &D, ParsedType &Ty, SourceLocation RParenLoc, Expr *CastExpr) {\n  // ...\n  if ((getLangOpts().AltiVec || getLangOpts().ZVector || getLangOpts().OpenCL) && castType->isVectorType() && (PE || PLE)) {\n    if (PLE && PLE->getNumExprs() == 0) {\n      Diag(PLE->getExprLoc(), diag::err_altivec_empty_initializer);"}}

[b]={q,1237025389,m,m},

[h]={{s,1714,"/// TryStaticDowncast - Common functionality of TryStaticReferenceDowncast and\n/// TryStaticPointerDowncast. Tests whether a static downcast from SrcType to\n/// DestType is possible and allowed.\nTryCastResult TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, bool CStyle, SourceRange OpRange, QualType OrigSrcType, QualType OrigDestType, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath) {\n  // ...\n  if (Paths.isAmbiguous(SrcType.getUnqualifiedType())) {\n    // ...\n    Self.Diag(OpRange.getBegin(), diag::err_ambiguous_base_to_derived_cast) << QualType(SrcType).getUnqualifiedType() << QualType(DestType).getUnqualifiedType() << PathDisplayStr << OpRange;"}},

[b]={"c34c179f4bcd",1253035307,"Perform overload resolution when selecting a pointer conversion\nfunction for delete of a class expre...","Perform overload resolution when selecting a pointer conversion\nfunction for delete of a class expression and issue\ngood diagnostic when result is ambiguous.\n\nllvm-svn: 81870"},

[h]={{t,3646,"/// ActOnCXXDelete - Parsed a C++ \'delete\' expression (C++ 5.3.5), as in:\n/// @code ::delete ptr; @endcode\n/// or\n/// @code delete [] ptr; @endcode\nExprResult Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool ArrayForm, Expr *ExE) {\n  // ...\n  if (!Ex.get()->isTypeDependent()) {\n    // ...\n    class DeleteConverter : public ContextualImplicitConverter {\n      // ...\n      SemaDiagnosticBuilder diagnoseAmbiguous(Sema &S, SourceLocation Loc, QualType T) override { return S.Diag(Loc, diag::err_ambiguous_delete_operand) << T; }"}},

[b]={q,1237025389,m,m},

[h]={{r,3167,"bool Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath, bool IgnoreAccess) { return CheckDerivedToBaseConversion(Derived, Base, diag::err_upcast_to_inaccessible_base, diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(), BasePath, IgnoreAccess); }"},{R,3147,"/// CheckPointerConversion - Check the pointer conversion from the\n/// expression From to the type ToType. This routine checks for\n/// ambiguous or inaccessible derived-to-base pointer\n/// conversions for which IsPointerConversion has already returned\n/// true. It returns true and produces a diagnostic if there was an\n/// error, or returns false otherwise.\nbool Sema::CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose) {\n  // ...\n  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {\n    if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {\n      // ...\n      if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {\n        // ...\n        if (Diagnose) {\n          // ...\n          AmbiguousID = diag::err_ambiguous_derived_to_base_conv;"}},

[Ab]={"clang/test/SemaCXX/dynamic-cast.cpp:62:9: error: ambiguous conversion from derived class \'F\' to base class \'A\':","clang/test/SemaCXX/dynamic-cast.cpp:63:9: error: ambiguous conversion from derived class \'F\' to base class \'A\':"}

[b]={M,1625925174,K,L},

[h]={{n,18540,"/// [class.dtor]p4:\n///  At the end of the definition of a class, overload resolution is\n///  performed among the prospective destructors declared in that class with\n///  an empty argument list to select the destructor for the class, also\n///  known as the selected destructor.\n///\n/// We do the overload resolution here, then mark the selected constructor in the AST.\n/// Later CXXRecordDecl::getDestructor() will return the selected constructor.\nstatic void ComputeSelectedDestructor(Sema &S, CXXRecordDecl *Record) {\n  // ...\n  case OR_Ambiguous:\n    Msg = diag::err_ambiguous_destructor;"}},

[b]={"5179eb78210a",1467140637,"P0136R1, DR1573, DR1645, DR1715, DR1736, DR1903, DR1941, DR1959, DR1991:\n\nReplace inheriting constru...","P0136R1, DR1573, DR1645, DR1715, DR1736, DR1903, DR1941, DR1959, DR1991:\n\nReplace inheriting constructors implementation with new approach, voted into\nC++ last year as a DR against C++11.\n\nInstead of synthesizing a set of derived class constructors for each inherited\nbase class constructor, we make the constructors of the base class visible to\nconstructor lookup in the derived class, using the normal rules for\nusing-declarations.\n\nFor constructors, UsingShadowDecl now has a ConstructorUsingShadowDecl derived\nclass that tracks the requisite additional information. We create shadow\nconstructors (not found by name lookup) in the derived class to model the\nactual initialization, and have a new expression node,\nCXXInheritedCtorInitExpr, to model the initialization of a base class from such\na constructor. (This initialization is special because it performs real perfect\nforwarding of arguments.)\n\nIn cases where argument forwarding is not possible (for inalloca calls,\nvariadic calls, and calls with callee parameter cleanup), the shadow inheriting\nconstructor is not emitted and instead we directly emit the initialization code\ninto the caller of the inherited constructor.\n\nNote that this new model is not perfectly compatible with the old model in some\ncorner cases. In particular:\n * if B inherits a private constructor from A, and C uses that constructor to\n  construct a B, then we previously required that A befriends B and B\n  befriends C, but the new rules require A to befriend C directly, and\n * if a derived class has its own constructors (and so its implicit default\n  constructor is suppressed), it may still inherit a default constructor from\n  a base class\n\nllvm-svn: 274049"},

[h]={{r,7302,"class Sema::InheritedConstructorInfo {\n  // ...\n  InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow) : S(S), UseLoc(UseLoc) {\n    // ...\n    // Find the set of such base class subobjects and check that there\'s a\n    // unique constructed subobject.\n    for (auto *D : Shadow->redecls()) {\n      // ...\n      // [class.inhctor.init]p2:\n      //  If the constructor was inherited from multiple base class subobjects\n      //  of type B, the program is ill-formed.\n      if (!ConstructedBase) {\n      // ...\n      } else if (ConstructedBase != DConstructedBase && !Shadow->isInvalidDecl()) {\n        if (!DiagnosedMultipleConstructedBases) {\n          S.Diag(UseLoc, diag::err_ambiguous_inherited_constructor) << Shadow->getTargetDecl();"}},

[b]={q,1237025389,m,m},

[b]={q,1237025389,m,m},

[b]={q,1237025389,m,m},

[h]={{s,1816,"/// TryStaticMemberPointerUpcast - Tests whether a conversion according to\n/// C++ 5.2.9p9 is valid:\n///\n///  An rvalue of type \"pointer to member of D of type cv1 T\" can be\n///  converted to an rvalue of type \"pointer to member of B of type cv2 T\",\n///  where B is a base class of D [...].\n///\nTryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath) {\n  // ...\n  // B is a base of D. But is it an allowed base? If not, it\'s a hard error.\n  if (Paths.isAmbiguous(Self.Context.getCanonicalType(DestClass))) {\n    // ...\n    Self.Diag(OpRange.getBegin(), diag::err_ambiguous_memptr_conv) << 1 << SrcClass << DestClass << PathDisplayStr << OpRange;"},{R,3278,"/// CheckMemberPointerConversion - Check the member pointer conversion from the\n/// expression From to the type ToType. This routine checks for ambiguous or\n/// virtual or inaccessible base-to-derived member pointer conversions\n/// for which IsMemberPointerConversion has already returned true. It returns\n/// true and produces a diagnostic if there was an error, or returns false\n/// otherwise.\nbool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess) {\n  // ...\n  if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).getUnqualifiedType())) {\n    // ...\n    Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv) << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();"}},

[b]={q,1237025389,m,m},

[b]={"66a8759400a9",1280881886,"Look through using declarations when deciding whether to use an operator\ndelete for a virtual destru...","Look through using declarations when deciding whether to use an operator\ndelete for a virtual destructor.  Diagnose ambiguities.\n\nFixes PR7803.\n\nllvm-svn: 110173"},

[h]={{t,3300,"bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, DeclarationName Name, FunctionDecl *&Operator, bool Diagnose, bool WantSize, bool WantAligned) {\n  // ...\n  // We found multiple suitable operators; complain about the ambiguity.\n  // FIXME: The standard doesn\'t say to do this; it appears that the intent\n  // is that this should never happen.\n  if (!Matches.empty()) {\n    if (Diagnose) {\n      Diag(StartLoc, diag::err_ambiguous_suitable_delete_member_function_found) << Name << RD;"}},

[b]={"6538c930503a",1255153699,"Qualified lookup through using declarations.  Diagnose a new type of ambiguity.\nSplit the various am...","Qualified lookup through using declarations.  Diagnose a new type of ambiguity.\nSplit the various ambiguous result enumerators into their own enum.  Tests\nfor most of C++ [namespace.qual].\n\nllvm-svn: 83700"},

[b]={Pb,1534346725,Ob,Nb},

[b]={Pb,1534346725,Ob,Nb},

[b]={Pb,1534346725,Ob,Nb},

[b]={Pb,1534346725,Ob,Nb},

[h]={{O,1106,"static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, bool &OptionField, StringRef Name, bool DefaultVal) {\n  // ...\n  if (!PossiblyInvalidVal) {\n    if (Diags)\n      Diags->Report(diag::err_analyzer_config_invalid_input) << Name << \"a boolean\";"},{O,1123,"static void initOption(AnalyzerOptions::ConfigTable &Config, DiagnosticsEngine *Diags, unsigned &OptionField, StringRef Name, unsigned DefaultVal) {\n  // ...\n  if (Diags && HasFailed)\n    Diags->Report(diag::err_analyzer_config_invalid_input) << Name << \"an unsigned\";"},{O,1181,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  // ...\n  if (AnOpts.ShouldTrackConditionsDebug && !AnOpts.ShouldTrackConditions)\n    Diags->Report(diag::err_analyzer_config_invalid_input) << \"track-conditions-debug\""},{O,1185,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  // ...\n  if (!AnOpts.CTUDir.empty() && !llvm::sys::fs::is_directory(AnOpts.CTUDir))\n    Diags->Report(diag::err_analyzer_config_invalid_input) << \"ctu-dir\""},{O,1190,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  // ...\n  if (!AnOpts.ModelPath.empty() && !llvm::sys::fs::is_directory(AnOpts.ModelPath))\n    Diags->Report(diag::err_analyzer_config_invalid_input) << \"model-path\""}}

[b]={"fb5351eed39a",1346219700,"Add new -cc1 driver option -analyzer-config, which allows one to specify\na comma separated collectio...","Add new -cc1 driver option -analyzer-config, which allows one to specify\na comma separated collection of key:value pairs (which are strings).  This\nallows a general way to provide analyzer configuration data from the command line.\n\nNo clients yet.\n\nllvm-svn: 162827"},

[h]={{O,1045,"#include \"clang/StaticAnalyzer/Core/Analyses.def\"\n  // ...\n  // Go through the analyzer configuration options.\n  for (const auto *A : Args.filtered(OPT_analyzer_config)) {\n    // ...\n    for (const auto &configVal : configVals) {\n      // ...\n      if (val.contains(\'=\')) {\n        Diags.Report(SourceLocation(), diag::err_analyzer_config_multiple_values) << configVal;"}}

[b]={"fb5351eed39a",1346219700,"Add new -cc1 driver option -analyzer-config, which allows one to specify\na comma separated collectio...","Add new -cc1 driver option -analyzer-config, which allows one to specify\na comma separated collection of key:value pairs (which are strings).  This\nallows a general way to provide analyzer configuration data from the command line.\n\nNo clients yet.\n\nllvm-svn: 162827"},

[h]={{O,1040,"#include \"clang/StaticAnalyzer/Core/Analyses.def\"\n  // ...\n  // Go through the analyzer configuration options.\n  for (const auto *A : Args.filtered(OPT_analyzer_config)) {\n    // ...\n    for (const auto &configVal : configVals) {\n      // ...\n      if (val.empty()) {\n        Diags.Report(SourceLocation(), diag::err_analyzer_config_no_value) << configVal;"}}

[b]={Pb,1534346725,Ob,Nb},

[h]={{O,1054,"#include \"clang/StaticAnalyzer/Core/Analyses.def\"\n  // ...\n  // Go through the analyzer configuration options.\n  for (const auto *A : Args.filtered(OPT_analyzer_config)) {\n    // ...\n    for (const auto &configVal : configVals) {\n      // ...\n      // TODO: Check checker options too, possibly in CheckerRegistry.\n      // Leave unknown non-checker configs unclaimed.\n      if (!key.contains(\":\") && Opts.isUnknownAnalyzerConfig(key)) {\n        if (Opts.ShouldEmitErrorsOnInvalidConfigValue)\n          Diags.Report(diag::err_analyzer_config_unknown) << key;"}}

[b]={"0687578728ea",1610286626,"[C++20][Modules][HU 2/5] Support searching Header Units in user or system search paths.\n\nThis is sup...","[C++20][Modules][HU 2/5] Support searching Header Units in user or system search paths.\n\nThis is support for the user-facing options to create importable header units\nfrom headers in the user or system search paths (or to be given an absolute path).\n\nThis means that an incomplete header path will be passed by the driver and the\nlookup carried out using the search paths present when the front end is run.\n\nTo support this, we introduce file fypes for c++-{user,system,header-unit}-header.\nThese terms are the same as the ones used by GCC, to minimise the differences for\ntooling (and users).\n\nThe preprocessor checks for headers before issuing a warning for\n\"#pragma once\" in a header build.  We ensure that the importable header units\nare recognised as headers in order to avoid such warnings.\n\nDifferential Revision: https://reviews.llvm.org/D121096"},

[h]={{O,960,"#ifndef LLVM_WITH_Z3\n      if (Value == AnalysisConstraints::Z3ConstraintsModel) {\n        Diags.Report(diag::err_analyzer_not_built_with_z3);"}}

[b]={"f9b00eb7dc88",1240248578,"clean up anonymous bitfield diagnostics, PR4017\n\nllvm-svn: 69608","clean up anonymous bitfield diagnostics, PR4017\n\nllvm-svn: 69608"},

[h]={{n,17926,"// Note that FieldName may be null for anonymous bitfields.\nExprResult Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth) {\n  // ...\n  if (Value.isSigned() && Value.isNegative()) {\n    // ...\n    return Diag(FieldLoc, diag::err_anon_bitfield_has_negative_width) << toString(Value, 10);"}},

[g]=v,

[b]={"2e204e23911b",1601401476,"[clang] Enable support for #pragma STDC FENV_ACCESS\n\nReviewers: rjmccall, rsmith, sepavloff\n\nDiffere...","[clang] Enable support for #pragma STDC FENV_ACCESS\n\nReviewers: rjmccall, rsmith, sepavloff\n\nDifferential Revision: https://reviews.llvm.org/D87528"},

[h]={{I,3021,"/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.\n///\n///      member-declaration:\n///        decl-specifier-seq[opt] member-declarator-list[opt] \';\'\n///        function-definition \';\'[opt]\n///        ::[opt] nested-name-specifier template[opt] unqualified-id \';\'[TODO]\n///        using-declaration                                            [TODO]\n/// [C++0x] static_assert-declaration\n///        template-declaration\n/// [GNU]  \'__extension__\' member-declaration\n///\n///      member-declarator-list:\n///        member-declarator\n///        member-declarator-list \',\' member-declarator\n///\n///      member-declarator:\n///        declarator virt-specifier-seq[opt] pure-specifier[opt]\n/// [C++2a] declarator requires-clause\n///        declarator constant-initializer[opt]\n/// [C++11] declarator brace-or-equal-initializer[opt]\n///        identifier[opt] \':\' constant-expression\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\n///\n///      virt-specifier:\n///        override\n///        final\n/// [MS]    sealed\n///\n///      pure-specifier:\n///        \'= 0\'\n///\n///      constant-initializer:\n///        \'=\' constant-expression\n///\nParser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, ParsedAttributes &AccessAttrs, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject *TemplateDiags) {\n  // ...\n  while (true) {\n    // ...\n    if (Tok.isOneOf(tok::equal, tok::l_brace) && PureSpecLoc.isInvalid()) {\n      // DRXXXX: Anonymous bit-fields cannot have a brace-or-equal-initializer.\n      if (BitfieldSize.isUsable() && !DeclaratorInfo.hasName()) {\n        // ...\n        Diag(Tok, diag::err_anon_bitfield_member_init);"}},

[b]={"33e90d160b1b",1521320920,"Implement DR2229, which prohibits unnamed bit-fields from having qualifiers in C++.\n\nllvm-svn: 32778...","Implement DR2229, which prohibits unnamed bit-fields from having qualifiers in C++.\n\nllvm-svn: 327781"},

[h]={{n,18153,"/// Build a new FieldDecl and check its well-formedness.\n///\n/// This routine builds a new FieldDecl given the fields name, type,\n/// record, etc. \\p PrevDecl should refer to any previous declaration\n/// with the same name and in the same scope as the field to be\n/// created.\n///\n/// \\returns a new FieldDecl.\n///\n/// \\todo The Declarator argument is a hack. It will be removed once\nFieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D) {\n  // ...\n  // Anonymous bit-fields cannot be cv-qualified (CWG 2229).\n  if (!InvalidDecl && getLangOpts().CPlusPlus && !II && BitWidth && T.hasQualifiers()) {\n    // ...\n    Diag(Loc, diag::err_anon_bitfield_qualifiers);"}},

[g]=v,

[b]={x,1236199783,y,w},

[h]={{I,1949,"#include \"clang/Basic/TransformTypeTraits.def\"\n  // ...\n  if (!Name && !TemplateId && (DS.getTypeSpecType() == DeclSpec::TST_error || TUK != Sema::TUK_Definition)) {\n    if (DS.getTypeSpecType() != DeclSpec::TST_error) {\n      // ...\n      Diag(StartLoc, diag::err_anon_type_definition) << DeclSpec::getSpecifierName(TagType, Policy);"}},

[g]=v,

[b]={"c90e19810743",1588991058,"Fix parsing of enum-base to follow C++11 rules.\n\nPreviously we implemented non-standard disambiguati...","Fix parsing of enum-base to follow C++11 rules.\n\nPreviously we implemented non-standard disambiguation rules to\ndistinguish an enum-base from a bit-field but otherwise treated a :\nafter an elaborated-enum-specifier as introducing an enum-base. That\nmisparses various examples (anywhere an elaborated-type-specifier can\nappear followed by a colon, such as within a ternary operator or\n_Generic).\n\nWe now implement the C++11 rules, with the old cases accepted as\nextensions where that seemed reasonable. These amount to:\n * an enum-base must always be accompanied by an enum definition (except\n  in a standalone declaration of the form \'enum E : T;\')\n * in a member-declaration, \'enum E :\' always introduces an enum-base,\n  never a bit-field\n * in a type-specifier (or similar context), \'enum E :\' is not\n  permitted; the colon means whatever else it would mean in that\n  context.\n\nFixed underlying types for enums are also permitted in Objective-C and\nunder MS extensions, plus as a language extension in all other modes.\nThe behavior in ObjC and MS extensions modes is unchanged (but the\nbit-field disambiguation is a bit better); remaining language modes\nfollow the C++11 rules.\n\nFixes PR45726, PR39979, PR19810, PR44941, and most of PR24297, plus C++\ncore issues 1514 and 1966."},

[h]={{A,4919,"/// ParseEnumSpecifier\n///      enum-specifier: [C99 6.7.2.2]\n///        \'enum\' identifier[opt] \'{\' enumerator-list \'}\'\n///[C99/C++]\'enum\' identifier[opt] \'{\' enumerator-list \',\' \'}\'\n/// [GNU]  \'enum\' attributes[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\' attributes[opt]\n/// [MS]    \'enum\' __declspec[opt] identifier[opt] \'{\' enumerator-list \',\' [opt]\n///                                                \'}\'\n///        \'enum\' identifier\n/// [GNU]  \'enum\' attributes[opt] identifier\n///\n/// [C++11] enum-head \'{\' enumerator-list[opt] \'}\'\n/// [C++11] enum-head \'{\' enumerator-list \',\'  \'}\'\n///\n///      enum-head: [C++11]\n///        enum-key attribute-specifier-seq[opt] identifier[opt] enum-base[opt]\n///        enum-key attribute-specifier-seq[opt] nested-name-specifier\n///            identifier enum-base[opt]\n///\n///      enum-key: [C++11]\n///        \'enum\'\n///        \'enum\' \'class\'\n///        \'enum\' \'struct\'\n///\n///      enum-base: [C++11]\n///        \':\' type-specifier-seq\n///\n/// [C++] elaborated-type-specifier:\n/// [C++]  \'enum\' nested-name-specifier[opt] identifier\n///\nvoid Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSC) {\n  // ...\n  // Parse the fixed underlying type.\n  if (Tok.is(tok::colon)) {\n    // ...\n    if (CanBeBitfield && !isEnumBase(CanBeOpaqueEnumDeclaration)) {\n      // Outside C++11, do not interpret the tokens as an enum-base if they do\n      // not make sense as one. In C++11, it\'s an error if this happens.\n      if (getLangOpts().CPlusPlus11)\n        Diag(Tok.getLocation(), diag::err_anonymous_enum_bitfield);"}},

[b]={"5e77d76c953d",1366097310,"Basic support for Microsoft property declarations and\nreferences thereto.\n\nPatch by Tong Shen!\n\nllvm...","Basic support for Microsoft property declarations and\nreferences thereto.\n\nPatch by Tong Shen!\n\nllvm-svn: 179585"},

[h]={{r,18817,"/// HandleMSProperty - Analyze a __delcspec(property) field of a C++ class.\n///\nMSPropertyDecl *Sema::HandleMSProperty(Scope *S, RecordDecl *Record, SourceLocation DeclStart, Declarator &D, Expr *BitWidth, InClassInitStyle InitStyle, AccessSpecifier AS, const ParsedAttr &MSPropertyAttr) {\n  // ...\n  if (!II) {\n    Diag(DeclStart, diag::err_anonymous_property);"}},

[b]={q,1237025389,m,m},

[h]={{n,5645,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      // ...\n      } else if (Mem->isImplicit()) {\n      // ...\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      // ...\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      // ...\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      // ...\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      // ...\n      } else {\n        // ...\n        unsigned DK = diag::err_anonymous_record_bad_member;"}}

[b]={"da7b27ff0b98",1447738809,"[Sema] Combine similar diagnostics using %select. NFC\n\nllvm-svn: 253315","[Sema] Combine similar diagnostics using %select. NFC\n\nllvm-svn: 253315"},

[h]={{n,5358,"/// We are trying to inject an anonymous member into the given scope;\n/// check if there\'s an existing declaration that can\'t be overloaded.\n///\n/// \\return true if this is a forbidden redeclaration\nstatic bool CheckAnonMemberRedeclaration(Sema &SemaRef, Scope *S, DeclContext *Owner, DeclarationName Name, SourceLocation NameLoc, bool IsUnion) {\n  // ...\n  SemaRef.Diag(NameLoc, diag::err_anonymous_record_member_redecl) << IsUnion << Name;"}},

[b]={q,1237025389,m,m},

[h]={{n,5598,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n        // ...\n        if (FD->getAccess() != AS_public) {\n          Diag(FD->getLocation(), diag::err_anonymous_record_nonpublic_member) << Record->isUnion() << (FD->getAccess() == AS_protected);"}},

[b]={q,1237025389,m,m},

[h]={{n,5649,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      // ...\n      } else if (Mem->isImplicit()) {\n      // ...\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      // ...\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      // ...\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      // ...\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      // ...\n      } else {\n        // ...\n        if (isa<TypeDecl>(Mem))\n        // ...\n        else if (isa<FunctionDecl>(Mem))\n          DK = diag::err_anonymous_record_with_function;"}},

[b]={q,1237025389,m,m},

[h]={{n,5651,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      // ...\n      } else if (Mem->isImplicit()) {\n      // ...\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      // ...\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      // ...\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      // ...\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      // ...\n      } else {\n        // ...\n        if (isa<TypeDecl>(Mem))\n        // ...\n        else if (isa<FunctionDecl>(Mem))\n        // ...\n        else if (isa<VarDecl>(Mem))\n          DK = diag::err_anonymous_record_with_static;"}}

[b]={q,1237025389,m,m},

[h]={{n,5626,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      // ...\n      } else if (Mem->isImplicit()) {\n      // ...\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      // ...\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n        if (!MemRecord->isAnonymousStructOrUnion() && MemRecord->getDeclName()) {\n          // Visual C++ allows type definition in anonymous struct or union.\n          if (getLangOpts().MicrosoftExt)\n          // ...\n          else {\n            // ...\n            Diag(MemRecord->getLocation(), diag::err_anonymous_record_with_type) << Record->isUnion();"},{n,5647,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      // ...\n      } else if (Mem->isImplicit()) {\n      // ...\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      // ...\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      // ...\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      // ...\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      // ...\n      } else {\n        // ...\n        if (isa<TypeDecl>(Mem))\n          DK = diag::err_anonymous_record_with_type;"},{n,5655,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    // C++ [class.union]p2:\n    //  The member-specification of an anonymous union shall only\n    //  define non-static data members. [Note: nested types and\n    //  functions cannot be declared within an anonymous union. ]\n    for (auto *Mem : Record->decls()) {\n      // ...\n      if (auto *FD = dyn_cast<FieldDecl>(Mem)) {\n      // ...\n      } else if (Mem->isImplicit()) {\n      // ...\n      } else if (isa<TagDecl>(Mem) && Mem->getDeclContext() != Record) {\n      // ...\n      } else if (auto *MemRecord = dyn_cast<RecordDecl>(Mem)) {\n      // ...\n      } else if (isa<AccessSpecDecl>(Mem)) {\n      // ...\n      } else if (isa<StaticAssertDecl>(Mem)) {\n      // ...\n      } else {\n        // ...\n        if (getLangOpts().MicrosoftExt && DK == diag::err_anonymous_record_with_type)"}},

[b]={q,1237025389,m,m},

[h]={{n,5675,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (!Record->isUnion() && !Owner->isRecord()) {\n    Diag(Record->getLocation(), diag::err_anonymous_struct_not_member) << getLangOpts().CPlusPlus;"}},

[b]={q,1237025389,m,m},

[h]={{n,5530,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    if (Record->isUnion()) {\n      // ...\n      if (DS.getStorageClassSpec() != DeclSpec::SCS_static && (OwnerScope->isTranslationUnit() || (OwnerScope->isNamespace() && !cast<NamespaceDecl>(OwnerScope)->isAnonymousNamespace()))) {\n        Diag(Record->getLocation(), diag::err_anonymous_union_not_static) << FixItHint::CreateInsertion(Record->getLocation(), \"static \");"}},

[b]={q,1237025389,m,m},

[h]={{n,5543,"/// BuildAnonymousStructOrUnion - Handle the declaration of an\n/// anonymous structure or union. Anonymous unions are a C++ feature\n/// (C++ [class.union]) and a C11 feature; anonymous structures\n/// are a C11 feature and GNU C++ extension.\nDecl *Sema::BuildAnonymousStructOrUnion(Scope *S, DeclSpec &DS, AccessSpecifier AS, RecordDecl *Record, const PrintingPolicy &Policy) {\n  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    if (Record->isUnion()) {\n      // ...\n      }\n      // C++ [class.union]p6:\n      //  A storage class is not allowed in a declaration of an\n      //  anonymous union in a class scope.\n      else if (DS.getStorageClassSpec() != DeclSpec::SCS_unspecified && isa<RecordDecl>(Owner)) {\n        Diag(DS.getStorageClassSpecLoc(), diag::err_anonymous_union_with_storage_spec) << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());"}},

[b]={"d51e9933b6aa",1452830791,"[X86] Support \'interrupt\' attribute for x86\nThis attribute may be attached to a function definition ...","[X86] Support \'interrupt\' attribute for x86\nThis attribute may be attached to a function definition and instructs the backend to generate appropriate function entry/exit code so that\nit can be used directly as an interrupt handler.\nThe IRET instruction, instead of the RET instruction, is used to return from interrupt or exception handlers. All registers, except for the EFLAGS register which is restored by the IRET instruction, are preserved by the compiler.\nAny interruptible-without-stack-switch code must be compiled with -mno-red-zone since interrupt handlers can and will, because of the hardware design, touch\nthe red zone.\n\ninterrupt handler must be declared with a mandatory pointer argument:\nstruct interrupt_frame;\n\n__attribute__ ((interrupt))\nvoid f (struct interrupt_frame *frame) {\n    ...\n}\nand user must properly define the structure the pointer pointing to.\n\nexception handler: \n\nThe exception handler is very similar to the interrupt handler with a different mandatory function signature:\n#ifdef __x86_64__\ntypedef unsigned long long int uword_t;\n#else\ntypedef unsigned int uword_t;\n#endif\n\nstruct interrupt_frame;\n\n__attribute__ ((interrupt))\nvoid f (struct interrupt_frame *frame, uword_t error_code) {\n    ...\n}\nand compiler pops the error code off stack before the IRET instruction.\n\nThe exception handler should only be used for exceptions which push an error code and all other exceptions must use the interrupt handler.\nThe system will crash if the wrong handler is used.\nDifferential Revision: http://reviews.llvm.org/D15709\n\nllvm-svn: 257867"},

[b]={"d51e9933b6aa",1452830791,"[X86] Support \'interrupt\' attribute for x86\nThis attribute may be attached to a function definition ...","[X86] Support \'interrupt\' attribute for x86\nThis attribute may be attached to a function definition and instructs the backend to generate appropriate function entry/exit code so that\nit can be used directly as an interrupt handler.\nThe IRET instruction, instead of the RET instruction, is used to return from interrupt or exception handlers. All registers, except for the EFLAGS register which is restored by the IRET instruction, are preserved by the compiler.\nAny interruptible-without-stack-switch code must be compiled with -mno-red-zone since interrupt handlers can and will, because of the hardware design, touch\nthe red zone.\n\ninterrupt handler must be declared with a mandatory pointer argument:\nstruct interrupt_frame;\n\n__attribute__ ((interrupt))\nvoid f (struct interrupt_frame *frame) {\n    ...\n}\nand user must properly define the structure the pointer pointing to.\n\nexception handler: \n\nThe exception handler is very similar to the interrupt handler with a different mandatory function signature:\n#ifdef __x86_64__\ntypedef unsigned long long int uword_t;\n#else\ntypedef unsigned int uword_t;\n#endif\n\nstruct interrupt_frame;\n\n__attribute__ ((interrupt))\nvoid f (struct interrupt_frame *frame, uword_t error_code) {\n    ...\n}\nand compiler pops the error code off stack before the IRET instruction.\n\nThe exception handler should only be used for exceptions which push an error code and all other exceptions must use the interrupt handler.\nThe system will crash if the wrong handler is used.\nDifferential Revision: http://reviews.llvm.org/D15709\n\nllvm-svn: 257867"},

[h]={{u,7356,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy.  The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n  // ...\n  // Functions with \'interrupt\' attribute cannot be called directly.\n  if (FDecl && FDecl->hasAttr<AnyX86InterruptAttr>()) {\n    Diag(Fn->getExprLoc(), diag::err_anyx86_interrupt_called);"}},

[g]=J,

[b]={db,1308874139,cb,eb},

[h]={{n,14905,"ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC) {\n  // In ARC, infer a lifetime qualifier for appropriate parameter types.\n  if (getLangOpts().ObjCAutoRefCount && T.getObjCLifetime() == Qualifiers::OCL_None && T->isObjCLifetimeType()) {\n    // ...\n    // Special cases for arrays:\n    //  - if it\'s const, use __unsafe_unretained\n    //  - otherwise, it\'s an error\n    if (T->isArrayType()) {\n      if (!T.isConstQualified()) {\n        if (DelayedDiagnostics.shouldDelayDiagnostics())\n          DelayedDiagnostics.add(sema::DelayedDiagnostic::makeForbiddenType(NameLoc, diag::err_arc_array_param_no_ownership, T, false));"},{n,14907,"ParmVarDecl *Sema::CheckParameter(DeclContext *DC, SourceLocation StartLoc, SourceLocation NameLoc, IdentifierInfo *Name, QualType T, TypeSourceInfo *TSInfo, StorageClass SC) {\n  // In ARC, infer a lifetime qualifier for appropriate parameter types.\n  if (getLangOpts().ObjCAutoRefCount && T.getObjCLifetime() == Qualifiers::OCL_None && T->isObjCLifetimeType()) {\n    // ...\n    // Special cases for arrays:\n    //  - if it\'s const, use __unsafe_unretained\n    //  - otherwise, it\'s an error\n    if (T->isArrayType()) {\n      if (!T.isConstQualified()) {\n        if (DelayedDiagnostics.shouldDelayDiagnostics())\n        // ...\n        else\n          Diag(NameLoc, diag::err_arc_array_param_no_ownership) << TSInfo->getTypeLoc().getSourceRange();"},{l,9835,"/// Handle a delayed forbidden-type diagnostic.\nstatic void handleDelayedForbiddenType(Sema &S, DelayedDiagnostic &DD, Decl *D) {\n  // ...\n  if (S.getLangOpts().ObjCAutoRefCount)\n    if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n      // ...\n      if (FD->hasAttr<UnavailableAttr>() && DD.getForbiddenTypeDiagnostic() == diag::err_arc_array_param_no_ownership) {"}},

[b]={db,1308874139,cb,eb},

[h]={{bb,208,"class PropertiesRewriter {\n  // ...\n  void removeAssignForDefaultStrong(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{bb,237,"class PropertiesRewriter {\n  // ...\n  void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{bb,262,"class PropertiesRewriter {\n  // ...\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{P,777,"static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc, ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {\n  // ...\n  case Qualifiers::OCL_ExplicitNone:\n    S.Diag(ivar->getLocation(), diag::err_arc_assign_property_ownership) << property->getDeclName() << ivar->getDeclName() << ((property->getPropertyAttributesAsWritten() & ObjCPropertyAttribute::kind_assign) != 0);"}},

[g]=J,

[b]={db,1308874139,cb,eb},

[h]={{p,3238,"bool Sema::CheckARMBuiltinExclusiveCall(unsigned BuiltinID, CallExpr *TheCall, unsigned MaxWidth) {\n  // ...\n  case Qualifiers::OCL_Weak:\n  case Qualifiers::OCL_Strong:\n  case Qualifiers::OCL_Autoreleasing:\n    Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership) << ValType << PointerArg->getSourceRange();"},{p,7247,"ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder) {\n  // ...\n  case Qualifiers::OCL_Weak:\n  case Qualifiers::OCL_Strong:\n  case Qualifiers::OCL_Autoreleasing:\n    // ...\n    Diag(ExprRange.getBegin(), diag::err_arc_atomic_ownership) << ValType << Ptr->getSourceRange();"},{p,7582,"/// We have a call to a function like __sync_fetch_and_add, which is an\n/// overloaded function based on the pointer type of its first argument.\n/// The main BuildCallExpr routines have already promoted the types of\n/// arguments because all of these calls are prototyped as void(...).\n///\n/// This function goes through and does final semantic checking for these\n/// builtins, as well as generating any warnings.\nExprResult Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) {\n  // ...\n  case Qualifiers::OCL_Weak:\n  case Qualifiers::OCL_Strong:\n  case Qualifiers::OCL_Autoreleasing:\n    Diag(DRE->getBeginLoc(), diag::err_arc_atomic_ownership) << ValType << FirstArg->getSourceRange();"}},

[zb]={"clang/test/SemaObjC/arc.m:515:3: error: cannot perform atomic operation on a pointer to type \'__strong id\': type has non-trivial ownership"}

[g]=J,

[b]={"67cd5e094e43",1333085028,"Forbid the block and lambda copy-capture of __autoreleasing variables\nin ARC, under the usual reason...","Forbid the block and lambda copy-capture of __autoreleasing variables\nin ARC, under the usual reasoning limiting the use of __autoreleasing.\n\nllvm-svn: 153725"},

[h]={{u,19244,"// Returns true if the capture by block was successful.\nstatic bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid) {\n  // ...\n  // Forbid the block-capture of autoreleasing variables.\n  if (!Invalid && CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {\n    if (BuildAndDiagnose) {\n      S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*block*/ 0;"},{u,19394,"/// Capture the given variable in the lambda.\nstatic bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid) {\n  // ...\n  // Compute the type of the field that will capture this variable.\n  if (ByRef) {\n  // ...\n  } else {\n    // ...\n    // Forbid the lambda copy-capture of autoreleasing variables.\n    if (!Invalid && CaptureType.getObjCLifetime() == Qualifiers::OCL_Autoreleasing) {\n      if (BuildAndDiagnose) {\n        S.Diag(Loc, diag::err_arc_autoreleasing_capture) << /*lambda*/ 1;"}},

[g]=J,

[b]={E,1308178962,F,H},

[h]={{n,6876,"bool Sema::inferObjCARCLifetime(ValueDecl *decl) {\n  // ...\n  if (lifetime == Qualifiers::OCL_Autoreleasing) {\n    // ...\n    if (kind != -1U) {\n      Diag(decl->getLocation(), diag::err_arc_autoreleasing_var) << kind;"}},

[b]={E,1308178962,F,H},

[b]={E,1308178962,F,H},

[b]={"0c07bee8bd2c",1308347772,"Only accept __bridge_retain in system headers, as Doug suggested.\n\nllvm-svn: 133300","Only accept __bridge_retain in system headers, as Doug suggested.\n\nllvm-svn: 133300"},

[h]={{Cb,2982,"/// ParseParenExpression - This parses the unit that starts with a \'(\' token,\n/// based on what is allowed by ExprType.  The actual thing parsed is returned\n/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,\n/// not the parsed cast-expression.\n///\n/// \\verbatim\n///      primary-expression: [C99 6.5.1]\n///        \'(\' expression \')\'\n/// [GNU]  \'(\' compound-statement \')\'      (if !ParenExprOnly)\n///      postfix-expression: [C99 6.5.2]\n///        \'(\' type-name \')\' \'{\' initializer-list \'}\'\n///        \'(\' type-name \')\' \'{\' initializer-list \',\' \'}\'\n///      cast-expression: [C99 6.5.4]\n///        \'(\' type-name \')\' cast-expression\n/// [ARC]  bridged-cast-expression\n/// [ARC] bridged-cast-expression:\n///        (__bridge type-name) cast-expression\n///        (__bridge_transfer type-name) cast-expression\n///        (__bridge_retained type-name) cast-expression\n///      fold-expression: [C++1z]\n///        \'(\' cast-expression fold-operator \'...\' \')\'\n///        \'(\' \'...\' fold-operator cast-expression \')\'\n///        \'(\' cast-expression fold-operator \'...\'\n///                fold-operator cast-expression \')\'\n/// [OPENMP] Array shaping operation\n///      \'(\' \'[\' expression \']\' { \'[\' expression \']\' } cast-expression\n/// \\endverbatim\nExprResult Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, bool isTypeCast, ParsedType &CastTy, SourceLocation &RParenLoc) {\n  // ...\n  // None of these cases should fall through with an invalid Result\n  // unless they\'ve already reported an error.\n  if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {\n  // ...\n  } else if (ExprType >= CompoundLiteral && BridgeCast) {\n    // ...\n    if (tokenKind == tok::kw___bridge)\n    // ...\n    else if (tokenKind == tok::kw___bridge_transfer)\n    // ...\n    else if (tokenKind == tok::kw___bridge_retained)\n    // ...\n    else {\n      // ...\n      if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))\n        Diag(BridgeKeywordLoc, diag::err_arc_bridge_retain) << FixItHint::CreateReplacement(BridgeKeywordLoc, \"__bridge_retained\");"}},

[b]={E,1308178962,F,H},

[h]={{gb,210,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    // ...\n    if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc())) {"},{gb,227,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    // ...\n    TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc());"},{gb,303,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void rewriteBlockCopyMacro(CastExpr *E) {\n    // ...\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{gb,313,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void removeBlockReleaseMacro(CastExpr *E) {\n    // ...\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{C,3918,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\n    S.Diag(loc, diag::err_arc_cast_requires_bridge) << convKindForDiag << 2                                    // of C pointer type"},{C,3960,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\n    // ...\n    S.Diag(loc, diag::err_arc_cast_requires_bridge) << convKindForDiag << unsigned(castExprType->isBlockPointerType()) // of ObjC|block type"}},

[g]=J,

[b]={"538482373bba",1311728835,"Clean up the analysis of the collection operand to ObjC\nfor-in statements;  specifically, make sure ...","Clean up the analysis of the collection operand to ObjC\nfor-in statements;  specifically, make sure to close over any\ntemporaries or cleanups it might require.  In ARC, this has\nimplications for the lifetime of the collection, so emit it\nwith a retain and release it upon exit from the loop.\n\nrdar://problem/9817306\n\nllvm-svn: 136204"},

[h]={{Q,2244,"ExprResult Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {\n  // ...\n  if (iface && (getLangOpts().ObjCAutoRefCount ? RequireCompleteType(forLoc, QualType(objectType, 0), diag::err_arc_collection_forward, collection) : !isCompleteType(forLoc, QualType(objectType, 0)))) {"}},

[zb]={"clang/test/SemaObjC/arc.m:690:3: error: collection expression type \'Test37\' is a forward declaration"}

[g]=Rb,

[b]={"f2913401fc81",1310146902,"objc++-arc: more diagnosis of converting a weak-unavailable\nobject to a __weak object type. // rdar:...","objc++-arc: more diagnosis of converting a weak-unavailable\nobject to a __weak object type. // rdar://9732636\n\nllvm-svn: 134706"},

[h]={{s,3215,"/// Check the semantics of a C-style cast operation, in C.\nvoid CastOperation::CheckCStyleCast() {\n  // ...\n  // ARC imposes extra restrictions on casts.\n  if (Self.getLangOpts().allowsNonTrivialObjCLifetimeQualifiers()) {\n    // ...\n    if (Self.getLangOpts().ObjCAutoRefCount && CastPtr) {\n    // ...\n    } else if (!Self.CheckObjCARCUnavailableWeakConversion(DestType, SrcType)) {\n      Self.Diag(SrcExpr.get()->getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable) << 1 << SrcType << DestType << SrcExpr.get()->getSourceRange();"},{t,4497,"/// PerformImplicitConversion - Perform an implicit conversion of the\n/// expression From to the type ToType by following the standard\n/// conversion sequence SCS. Returns the converted\n/// expression. Flavor is the context in which we\'re performing this\n/// conversion, for use in error messages.\nExprResult Sema::PerformImplicitConversion(Expr *From, QualType ToType, const StandardConversionSequence &SCS, AssignmentAction Action, CheckedConversionKind CCK) {\n  // ...\n  case ICK_Writeback_Conversion:\n  case ICK_Pointer_Conversion: {\n    if (SCS.IncompatibleObjC && Action != AA_Casting) {\n    // ...\n    } else if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers() && !CheckObjCARCUnavailableWeakConversion(ToType, From->getType())) {\n      if (Action == AA_Initializing)\n      // ...\n      else\n        Diag(From->getBeginLoc(), diag::err_arc_convesion_of_weak_unavailable) << (Action == AA_Casting) << From->getType() << ToType << From->getSourceRange();"}},

[g]=J,

[b]={E,1308178962,F,H},

[Wb]={"clang/test/ARCMT/checking.m:240:1: error: method implementation does not match its declaration","clang/test/ARCMT/checking.m:261:1: error: method implementation does not match its declaration","clang/test/ARCMT/checking.m:268:1: error: method implementation does not match its declaration"}

[g]=xb,

[b]={E,1308178962,F,H},

[Wb]={"clang/test/ARCMT/checking.m:76:17: error: ARC forbids explicit message send of \'release\'","clang/test/ARCMT/checking.m:78:15: error: ARC forbids explicit message send of \'release\'","clang/test/ARCMT/checking.m:80:23: error: ARC forbids explicit message send of \'retain\'","clang/test/ARCMT/checking.m:84:15: error: ARC forbids explicit message send of \'retain\'","clang/test/ARCMT/checking.m:86:15: error: ARC forbids explicit message send of \'release\'","clang/test/ARCMT/checking.m:90:6: error: ARC forbids explicit message send of \'retainCount\'","clang/test/ARCMT/checking.m:93:6: error: ARC forbids explicit message send of \'autorelease\'","clang/test/ARCMT/checking.m:96:6: error: ARC forbids explicit message send of \'autorelease\'","clang/test/ARCMT/checking.m:307:3: error: ARC forbids explicit message send of \'release\'"}

[g]=xb,

[b]={E,1308178962,F,H},

[h]={{G,417,"/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible\n/// and user declared, in the method definition\'s AST.\nvoid Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {\n  // ...\n  // In ARC, disallow definition of retain/release/autorelease/retainCount\n  if (getLangOpts().ObjCAutoRefCount) {\n    // ...\n    case OMF_retain:\n    case OMF_retainCount:\n    case OMF_release:\n    case OMF_autorelease:\n      Diag(MDecl->getLocation(), diag::err_arc_illegal_method_def) << 0 << MDecl->getSelector();"},{P,1491,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // ...\n  if (ObjCMethodDecl *getterMethod = property->getGetterMethodDecl()) {\n    // ...\n    if (getLangOpts().ObjCAutoRefCount && Synthesize)\n      // ...\n      case OMF_retain:\n      case OMF_retainCount:\n      case OMF_release:\n      case OMF_autorelease:\n        Diag(getterMethod->getLocation(), diag::err_arc_illegal_method_def) << 1 << getterMethod->getSelector();"}},

[g]=xb,

[b]={E,1308178962,F,H},

[Wb]={"clang/test/ARCMT/checking.m:110:11: error: ARC forbids use of \'retain\' in a @selector","clang/test/ARCMT/checking.m:111:7: error: ARC forbids use of \'release\' in a @selector","clang/test/ARCMT/checking.m:112:7: error: ARC forbids use of \'autorelease\' in a @selector","clang/test/ARCMT/checking.m:113:7: error: ARC forbids use of \'dealloc\' in a @selector"}

[b]={db,1308874139,cb,eb},

[h]={{"clang/lib/ARCMigrate/TransGCAttrs.cpp",291,"static void checkAllAtProps(MigrationContext &MigrateCtx, SourceLocation AtLoc, IndivPropsTy &IndProps) {\n  // ...\n  for (unsigned i = 0, e = ATLs.size(); i != e; ++i) {\n    // ...\n    TA.clearDiagnostic(diag::err_arc_inconsistent_property_ownership, ATLs[i].second->getLocation());"},{bb,209,"class PropertiesRewriter {\n  // ...\n  void removeAssignForDefaultStrong(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{bb,238,"class PropertiesRewriter {\n  // ...\n  void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{bb,263,"class PropertiesRewriter {\n  // ...\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{P,99,"/// Check the internal consistency of a property declaration with\n/// an explicit ownership qualifier.\nstatic void checkPropertyDeclWithOwnership(Sema &S, ObjCPropertyDecl *property) {\n  // ...\n  S.Diag(property->getLocation(), diag::err_arc_inconsistent_property_ownership) << property->getDeclName() << expectedLifetime << propertyLifetime;"}},

[g]=J,

[b]={db,1308874139,cb,eb},

[h]={{o,2073,"/// Given that we\'re building a pointer or reference to the given\nstatic QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference) {\n  // ...\n  // If the object type is const-qualified, we can safely use\n  // __unsafe_unretained.  This is safe (because there are no read\n  // barriers), and it\'ll be safe to coerce anything but __weak* to\n  // the resulting type.\n  if (type.isConstQualified()) {\n  // ...\n  } else if (type->isObjCARCImplicitlyUnretainedType()) {\n  // ...\n  } else if (S.isUnevaluatedContext()) {\n  // ...\n  } else {\n    // These types can show up in private ivars in system headers, so\n    // we need this to not be an error in those cases.  Instead we\n    // want to delay.\n    if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {\n      S.DelayedDiagnostics.add(sema::DelayedDiagnostic::makeForbiddenType(loc, diag::err_arc_indirect_no_ownership, type, isReference));"},{o,2075,"/// Given that we\'re building a pointer or reference to the given\nstatic QualType inferARCLifetimeForPointee(Sema &S, QualType type, SourceLocation loc, bool isReference) {\n  // ...\n  // If the object type is const-qualified, we can safely use\n  // __unsafe_unretained.  This is safe (because there are no read\n  // barriers), and it\'ll be safe to coerce anything but __weak* to\n  // the resulting type.\n  if (type.isConstQualified()) {\n  // ...\n  } else if (type->isObjCARCImplicitlyUnretainedType()) {\n  // ...\n  } else if (S.isUnevaluatedContext()) {\n  // ...\n  } else {\n    // These types can show up in private ivars in system headers, so\n    // we need this to not be an error in those cases.  Instead we\n    // want to delay.\n    if (S.DelayedDiagnostics.shouldDelayDiagnostics()) {\n    // ...\n    } else {\n      S.Diag(loc, diag::err_arc_indirect_no_ownership) << type << isReference;"}},

[g]=J,

[b]={E,1308178962,F,H},

[Wb]={"clang/test/ARCMT/checking.m:231:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:232:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:233:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:234:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:235:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:236:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:253:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:254:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:255:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:256:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:257:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:258:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:274:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:275:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:276:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:277:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:278:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:279:1: error: init methods must return a type related to the receiver type","clang/test/ARCMT/checking.m:284:1: error: init methods must return a type related to the receiver type"}

[g]=J,

[b]={E,1308178962,F,H},

[Wb]={"clang/test/ARCMT/checking.m:246:1: error: method was declared as an \'init\' method, but its implementation doesn\'t match because its result type is not an object pointer","clang/test/ARCMT/checking.m:248:1: error: method was declared as an \'init\' method, but its implementation doesn\'t match because its result type is not an object pointer","clang/test/ARCMT/checking.m:249:1: error: method was declared as an \'init\' method, but its implementation doesn\'t match because its result type is not an object pointer","clang/test/ARCMT/checking.m:250:1: error: method was declared as an \'init\' method, but its implementation doesn\'t match because its result type is not an object pointer"}

[g]=J,

[b]={E,1308178962,F,H},

[g]=J,

[b]={E,1308178962,F,H},

[g]=xb,

[b]={E,1308178962,F,H},

[h]={{gb,209,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    // ...\n    if (!TA.hasDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc())) {"},{gb,226,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void rewriteToBridgedCast(CastExpr *E, ObjCBridgeCastKind Kind, Transaction &Trans) {\n    // ...\n    TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, E->getBeginLoc());"},{gb,302,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void rewriteBlockCopyMacro(CastExpr *E) {\n    // ...\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{gb,312,"class UnbridgedCastRewriter : public RecursiveASTVisitor<UnbridgedCastRewriter> {\n  // ...\n  void removeBlockReleaseMacro(CastExpr *E) {\n    // ...\n    Pass.TA.clearDiagnostic(diag::err_arc_mismatched_cast, diag::err_arc_cast_requires_bridge, OuterRange);"},{C,3997,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  S.Diag(loc, diag::err_arc_mismatched_cast) << !convKindForDiag << srcKind << castExprType << castType << castRange << castExpr->getSourceRange();"}},

[g]=J,

[b]={E,1308178962,F,H},

[zb]={"clang/test/SemaObjC/arc.m:407:3: error: multiple methods named \'test16_1:\' found with mismatched result, parameter type or attributes","clang/test/SemaObjC/arc.m:408:3: error: multiple methods named \'test16_2:\' found with mismatched result, parameter type or attributes","clang/test/SemaObjC/arc.m:409:3: error: multiple methods named \'test16_3:\' found with mismatched result, parameter type or attributes","clang/test/SemaObjC/arc.m:410:3: error: multiple methods named \'test16_4:\' found with mismatched result, parameter type or attributes","clang/test/SemaObjC/arc.m:411:3: error: multiple methods named \'test16_5:\' found with mismatched result, parameter type or attributes"}

[g]=J,

[b]={db,1308874139,cb,eb},

[h]={{t,2483,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  // C++ 5.3.4p1: \"[The] type shall be a complete object type, but not an\n  //  abstract class type or array thereof.\n  if (AllocType->isFunctionType())\n  // ...\n  else if (AllocType->isReferenceType())\n  // ...\n  else if (!AllocType->isDependentType() && RequireCompleteSizedType(Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))\n  // ...\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))\n  // ...\n  else if (AllocType->isVariablyModifiedType())\n  // ...\n  else if (AllocType.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n  // ...\n  else if (getLangOpts().ObjCAutoRefCount) {\n    if (const ArrayType *AT = Context.getAsArrayType(AllocType)) {\n      // ...\n      if (BaseAllocType.getObjCLifetime() == Qualifiers::OCL_None && BaseAllocType->isObjCLifetimeType())\n        return Diag(Loc, diag::err_arc_new_array_without_ownership) << BaseAllocType;"}}

[g]=xb,

[b]={"2fa646d59623",1319832367,"objective-c arc: type-casting of an objc pointer to\nan rvalue retainable object type with life-time ...","objective-c arc: type-casting of an objc pointer to\nan rvalue retainable object type with life-time qualifier has no\neffect and wil be diagnosed as error. // rdar://10244607\n\nllvm-svn: 143219"},

[g]=J,

[b]={E,1308178962,F,H},

[h]={{D,5948,"/// Check whether the given expression is a valid operand for an\n/// indirect copy/restore.\nstatic void checkIndirectCopyRestoreSource(Sema &S, Expr *src) {\n  // ...\n  S.Diag(src->getExprLoc(), diag::err_arc_nonlocal_writeback) << ((unsigned)iik - 1) // shift index into diagnostic explanations"}},

[g]=xb,

[b]={E,1308178962,F,H},

[h]={{bb,266,"class PropertiesRewriter {\n  // ...\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD) {\n        // ...\n        Pass.TA.clearDiagnostic(diag::err_arc_objc_property_default_assign_on_object, I->ImplD->getLocation());"},{P,1306,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // ...\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    // ...\n    if (!Ivar) {\n      // In ARC, give the ivar a lifetime qualifier based on the\n      // property attributes.\n      if ((getLangOpts().ObjCAutoRefCount || isARCWeak) && !PropertyIvarType.getObjCLifetime() && PropertyIvarType->isObjCRetainableType()) {\n        // It\'s an error if we have to do this and the user didn\'t\n        // explicitly write an ownership attribute on the property.\n        if (!hasWrittenStorageAttribute(property, QueryKind) && !(kind & ObjCPropertyAttribute::kind_strong)) {\n          Diag(PropertyDiagLoc, diag::err_arc_objc_property_default_assign_on_object);"}}

[b]={"b7a773626fea",1309905539,"objc-arc: enforce performSelector rules in rejecting retaining selectors\npassed to it, and unknown s...","objc-arc: enforce performSelector rules in rejecting retaining selectors\npassed to it, and unknown selectors causing potential leak.\n// rdar://9659270\n\nllvm-svn: 134449"},

[g]=J,

[b]={E,1308178962,F,H},

[h]={{t,7822,"ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeTypeInfo, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage Destructed) {\n  // ...\n  // C++ [expr.pseudo]p2:\n  //  [...] The cv-unqualified versions of the object type and of the type\n  //  designated by the pseudo-destructor-name shall be the same type.\n  if (DestructedTypeInfo) {\n    // ...\n    if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {\n      if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {\n      // ...\n      } else if (DestructedType.getObjCLifetime() != ObjectType.getObjCLifetime()) {\n        if (DestructedType.getObjCLifetime() == Qualifiers::OCL_None) {\n        // ...\n        } else {\n          Diag(DestructedTypeStart, diag::err_arc_pseudo_dtor_inconstant_quals) << ObjectType << DestructedType << Base->getSourceRange() << DestructedTypeInfo->getTypeLoc().getSourceRange();"}}

[g]=J,

[b]={E,1308178962,F,H},

[zb]={"clang/test/SemaObjC/arc.m:427:4: error: receiver \'Test17\' for class message is a forward declaration"}

[g]=J,

[b]={E,1308178962,F,H},

[zb]={"clang/test/SemaObjC/arc.m:422:4: error: receiver type \'Test17\' for instance message is a forward declaration","clang/test/SemaObjC/arc.m:425:4: error: receiver type \'Test17<Test17p>\' for instance message is a forward declaration"}

[b]={db,1308874139,cb,eb},

[h]={{bb,207,"class PropertiesRewriter {\n  // ...\n  void removeAssignForDefaultStrong(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{bb,236,"class PropertiesRewriter {\n  // ...\n  void rewriteAssign(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD)\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{bb,261,"class PropertiesRewriter {\n  // ...\n  void maybeAddWeakOrUnsafeUnretainedAttr(PropsTy &props, SourceLocation atLoc) const {\n    // ...\n    for (PropsTy::iterator I = props.begin(), E = props.end(); I != E; ++I) {\n      // ...\n      if (I->ImplD) {\n        Pass.TA.clearDiagnostic(diag::err_arc_strong_property_ownership, diag::err_arc_assign_property_ownership, diag::err_arc_inconsistent_property_ownership, I->IvarD->getLocation());"},{P,764,"static void checkARCPropertyImpl(Sema &S, SourceLocation propertyImplLoc, ObjCPropertyDecl *property, ObjCIvarDecl *ivar) {\n  // ...\n  case Qualifiers::OCL_Strong:\n    S.Diag(ivar->getLocation(), diag::err_arc_strong_property_ownership) << property->getDeclName() << ivar->getDeclName() << ivarLifetime;"}},

[g]=J,

[b]={db,1308874139,cb,eb},

[h]={{n,6893,"bool Sema::inferObjCARCLifetime(ValueDecl *decl) {\n  // ...\n  if (VarDecl *var = dyn_cast<VarDecl>(decl)) {\n    // Thread-local variables cannot have lifetime.\n    if (lifetime && lifetime != Qualifiers::OCL_ExplicitNone && var->getTLSKind()) {\n      Diag(var->getLocation(), diag::err_arc_thread_ownership) << var->getType();"}},

[zb]={"clang/test/SemaObjC/arc.m:448:20: error: thread-local variable has non-trivial ownership: type is \'__strong id\'","clang/test/SemaObjC/arc.m:449:29: error: thread-local variable has non-trivial ownership: type is \'__strong id\'","clang/test/SemaObjC/arc.m:450:27: error: thread-local variable has non-trivial ownership: type is \'__weak id\'","clang/test/SemaObjC/arc.m:451:36: error: thread-local variable has non-trivial ownership: type is \'__autoreleasing id\'","clang/test/SemaObjC/arc.m:454:22: error: thread-local variable has non-trivial ownership: type is \'__strong id\'","clang/test/SemaObjC/arc.m:455:31: error: thread-local variable has non-trivial ownership: type is \'__strong id\'","clang/test/SemaObjC/arc.m:456:29: error: thread-local variable has non-trivial ownership: type is \'__weak id\'","clang/test/SemaObjC/arc.m:457:38: error: thread-local variable has non-trivial ownership: type is \'__autoreleasing id\'"}

[b]={"3a25d0d59395",1375312774,"ObjectiveC ARC: finishing off issuing error when\nretainable pointer is passed to an audited CF funct...","ObjectiveC ARC: finishing off issuing error when\nretainable pointer is passed to an audited CF function\nexpecting CF type. // rdar://14569171\n\nllvm-svn: 187543"},

[h]={{u,17563,"bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, SourceLocation Loc, QualType DstType, QualType SrcType, Expr *SrcExpr, AssignmentAction Action, bool *Complained) {\n  // ...\n  case IncompatiblePointer:\n    if (Action == AA_Passing_CFAudited) {\n      DiagKind = diag::err_arc_typecheck_convert_incompatible_pointer;"}},

[b]={"3deb1ad40ca6",1345517263,"Screw around with ObjCRuntime some more, changing the\ndiagnostics for bad deployment targets and add...","Screw around with ObjCRuntime some more, changing the\ndiagnostics for bad deployment targets and adding a few\nmore predicates.  Includes a patch by Jonathan Schleifer\nto enable ARC for ObjFW.\n\nllvm-svn: 162252"},

[h]={{O,3665,"#include \"clang/Driver/Options.inc\"\n  // ...\n  if (Opts.ObjC) {\n    // ...\n    if (Args.hasArg(OPT_fobjc_gc_only))\n    // ...\n    else if (Args.hasArg(OPT_fobjc_gc))\n    // ...\n    else if (Args.hasArg(OPT_fobjc_arc)) {\n      // ...\n      if (!Opts.ObjCRuntime.allowsARC())\n        Diags.Report(diag::err_arc_unsupported_on_runtime);"}}

[b]={"3deb1ad40ca6",1345517263,"Screw around with ObjCRuntime some more, changing the\ndiagnostics for bad deployment targets and add...","Screw around with ObjCRuntime some more, changing the\ndiagnostics for bad deployment targets and adding a few\nmore predicates.  Includes a patch by Jonathan Schleifer\nto enable ARC for ObjFW.\n\nllvm-svn: 162252"},

[g]=Rb,

[b]={"1f626d6fd1ca",1309980245,"objc-arc: Support objc_arc_weak_unavailable on those\nclasses which are incompatible with weak refere...","objc-arc: Support objc_arc_weak_unavailable on those\nclasses which are incompatible with weak references.\n// rdar://9693477\n\nllvm-svn: 134522"},

[h]={{"clang/lib/ARCMigrate/TransGCAttrs.cpp",211,"static void checkWeakGCAttrs(MigrationContext &MigrateCtx) {\n  // ...\n  for (unsigned i = 0, e = MigrateCtx.GCAttrs.size(); i != e; ++i) {\n    // ...\n    if (Attr.Kind == MigrationContext::GCAttrOccurrence::Weak) {\n      // ...\n      if (!canApplyWeak(MigrateCtx.Pass.Ctx, Attr.ModifiedType,\n        // ...\n        TA.clearDiagnostic(diag::err_arc_weak_no_runtime, diag::err_arc_unsupported_weak_class, Attr.Loc);"},{o,7074,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  // ...\n  // Forbid __weak for class objects marked as\n  // objc_arc_weak_reference_unavailable\n  if (lifetime == Qualifiers::OCL_Weak) {\n    if (const ObjCObjectPointerType *ObjT = type->getAs<ObjCObjectPointerType>()) {\n      if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) {\n        if (Class->isArcWeakrefUnavailable()) {\n          S.Diag(AttrLoc, diag::err_arc_unsupported_weak_class);"}},

[g]=xb,

[b]={E,1308178962,F,H},

[h]={{"clang/lib/ARCMigrate/TransUnusedInitDelegate.cpp",53,"class UnusedInitRewriter : public RecursiveASTVisitor<UnusedInitRewriter> {\n  // ...\n  bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {\n    if (ME->isDelegateInitCall() && isRemovable(ME) && Pass.TA.hasDiagnostic(diag::err_arc_unused_init_message, ME->getExprLoc())) {"},{"clang/lib/ARCMigrate/TransUnusedInitDelegate.cpp",56,"class UnusedInitRewriter : public RecursiveASTVisitor<UnusedInitRewriter> {\n  // ...\n  bool VisitObjCMessageExpr(ObjCMessageExpr *ME) {\n    if (ME->isDelegateInitCall() && isRemovable(ME) && Pass.TA.hasDiagnostic(diag::err_arc_unused_init_message, ME->getExprLoc())) {\n      // ...\n      Pass.TA.clearDiagnostic(diag::err_arc_unused_init_message, ME->getExprLoc());"},{Q,328,"void Sema::DiagnoseUnusedExprResult(const Stmt *S, unsigned DiagID) {\n  // ...\n  if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(E)) {\n    if (getLangOpts().ObjCAutoRefCount && ME->isDelegateInitCall()) {\n      Diag(Loc, diag::err_arc_unused_init_message) << R1;"}},

[zb]={"clang/test/SemaObjC/arc.m:528:3: error: the result of a delegate init call must be immediately returned or assigned to \'self\'"}

[g]=Rb,

[b]={"460ce58fa6a1",1445539097,"Define weak and __weak to mean ARC-style weak references, even in MRC.\n\nPreviously, __weak was silen...","Define weak and __weak to mean ARC-style weak references, even in MRC.\n\nPreviously, __weak was silently accepted and ignored in MRC mode.\nThat makes this a potentially source-breaking change that we have to\nroll out cautiously.  Accordingly, for the time being, actual support\nfor __weak references in MRC is experimental, and the compiler will\nreject attempts to actually form such references.  The intent is to\neventually enable the feature by default in all non-GC modes.\n(It is, of course, incompatible with ObjC GC\'s interpretation of\n__weak.)\n\nIf you like, you can enable this feature with\n  -Xclang -fobjc-weak\nbut like any -Xclang option, this option may be removed at any point,\ne.g. if/when it is eventually enabled by default.\n\nThis patch also enables the use of the ARC __unsafe_unretained qualifier\nin MRC.  Unlike __weak, this is being enabled immediately.  Since\nvariables are essentially __unsafe_unretained by default in MRC,\nthe only practical uses are (1) communication and (2) changing the\ndefault behavior of by-value block capture.\n\nAs an implementation matter, this means that the ObjC ownership\nqualifiers may appear in any ObjC language mode, and so this patch\nremoves a number of checks for getLangOpts().ObjCAutoRefCount\nthat were guarding the processing of these qualifiers.  I don\'t\nexpect this to be a significant drain on performance; it may even\nbe faster to just check for these qualifiers directly on a type\n(since it\'s probably in a register anyway) than to do N dependent\nloads to grab the LangOptions.\n\nrdar://9674298\n\nllvm-svn: 251041"},

[h]={{l,9802,"/// Is the given declaration allowed to use a forbidden type?\n/// If so, it\'ll still be annotated with an attribute that makes it\n/// illegal to actually use.\nstatic bool isForbiddenTypeAllowed(Sema &S, Decl *D, const DelayedDiagnostic &diag, UnavailableAttr::ImplicitReason &reason) {\n  // ...\n  // Silently accept unsupported uses of __weak in both user and system\n  // declarations when it\'s been disabled, for ease of integration with\n  // -fno-objc-arc files.  We do have to take some care against attempts\n  // to define such things;  for now, we\'ve only done that for ivars\n  // and properties.\n  if ((isa<ObjCIvarDecl>(D) || isa<ObjCPropertyDecl>(D))) {\n    if (diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_disabled || diag.getForbiddenTypeDiagnostic() == diag::err_arc_weak_no_runtime) {"},{G,3794,"/// Diagnose attempts to define ARC-__weak ivars when __weak is disabled.\nstatic void DiagnoseWeakIvars(Sema &S, ObjCImplementationDecl *ID) {\n  // ...\n  for (auto ivar = ID->getClassInterface()->all_declared_ivar_begin(); ivar; ivar = ivar->getNextIvar()) {\n    // ...\n    if (ivar->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {\n      if (S.getLangOpts().ObjCWeakRuntime) {\n        S.Diag(ivar->getLocation(), diag::err_arc_weak_disabled);"},{o,7057,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  // ...\n  // Sometimes, __weak isn\'t allowed.\n  if (lifetime == Qualifiers::OCL_Weak && !S.getLangOpts().ObjCWeak && !NonObjCPointer) {\n    // ...\n    unsigned diagnostic = (S.getLangOpts().ObjCWeakRuntime ? diag::err_arc_weak_disabled : diag::err_arc_weak_no_runtime);"}},