Module:ClangDiags/DiagsLongData0: Difference between revisions

local b="regex2";

local c="commit";

local d="id_hist";

local e="message_hist";

local f="hierarchical_hist";

local g="category_hist";

local h="regex1";

local i="regex3";

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

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

local r="10.0";

local s="12.0";

local u="15.0";

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

local z="13.0";

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

local B="6.0";

local C="7.0";

local D="5.0";

local G="Inline Assembly Issue";

local H="16.0";

local I="b1c4d5507fad";

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

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

local L="The basic representation of diagnostics information in tablegen format, plus (uncommented and incomplete) test conversions of the existing def files to this format.\n\nllvm-svn: 66064";

local M="Automatic Reference Counting.";

local N="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 O="31168b077c36";

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

local Q="9.0";

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

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

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

local U="ARC Semantic Issue";

local V="private";

local X="clang/lib/Sema/SemaExprObjC.cpp";

local Y="protected";

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

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

local bb="Implement P2361 Unevaluated string literals\n\nThis patch proposes to handle in an uniform fashion\nthe parsing of strings that are never evaluated,\nin asm statement, static assert, attrributes, extern,\netc.\n\nUnevaluated strings are UTF-8 internally and so currently\nbehave as narrow strings, but these things will diverge with\nD93031.\n\nThe big question both for this patch and the P2361 paper\nis whether we risk breaking code by disallowing\nencoding prefixes in this context.\nI hope this patch may allow to gather some data on that.\n\nFuture work:\nImprove the rendering of unicode characters, line break\nand so forth in static-assert messages\n\nReviewed By: aaron.ballman, shafik\n\nDifferential Revision: https://reviews.llvm.org/D105759";

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

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

local kb="Rename objc_lifetime -> objc_ownership, and modify diagnostics to talk about \'ownership\', not \'lifet...";

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

local ob="clang/lib/ARCMigrate/TransUnbridgedCasts.cpp";

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

local qb="Implement most of N3638 (return type deduction for normal functions).";

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

local ub="ARC Restrictions";

local vb=" destructor";

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

local yb="ARC Weak References";

local zb="30482bc78659";

local Ab="Implement the C++0x deduced \'auto\' feature.";

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

local Cb="931fcd3ba011";

local Fb="Perform access control for the implicit base and member destructor calls";

local Gb="Perform access control for the implicit base and member destructor calls\nrequired when emitting a destructor definition.\n\nllvm-svn: 98609";

local Hb="\'decltype(auto)\'";

local Ib="11.1";

local Qb="[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 Rb="14f6bfcb52e7";

local Sb="struct";

local Tb="union";

local Ub="[clang] Implement objc_non_runtime_protocol to remove protocol metadata";

local Vb="clang/test/ARCMT/checking.m";

local Wb="f9c3310d32c6";

local Xb="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 Yb="AMDGPU: Teach toolchain to link rocm device libs";

local gc="Objective-C";

local hc="functions and methods";

local sc="clang/lib/Lex/Pragma.cpp";

local tc="functions";

local uc="block";

[d]="backslash_newline_space",

[f]="backslash and newline separated by space",

[h]="(?:warning|error|fatal error)\\: ",

[b]="backslash and newline separated by space",

[i]=" \\[(?:\\-Werror,)?\\-Wbackslash\\-newline\\-escape[^\\]]*\\]",

[g]="Lexical or Preprocessor Issue",

[c]={I,1236199783,K,L},

[d]={{nil,C,"err_32_bit_builtin_64_bit_tgt"}},

[e]={{nil,C,"this builtin is only available on 32-bit targets"}},

[f]={{nil,C,"this builtin is only available on 32-bit targets"}},

[h]=k,

[b]="this builtin is only available on 32\\-bit targets",

[i]=a,

[g]={{nil,C,m}},

[c]={"51738f834ed9",1524773686,"[X86] Make __builtin_ia32_readeflags_u32 and __builtin_ia32_writeeflags_u32 only available on 32-bit...","[X86] Make __builtin_ia32_readeflags_u32 and __builtin_ia32_writeeflags_u32 only available on 32-bit targets.\n\nThese builtins can\'t be handled by the backend on 64-bit targets. So error up front instead of throwing an isel error.\n\nFixes PR37225\n\nDifferential Revision: https://reviews.llvm.org/D46132\n\nllvm-svn: 330987"},

[d]="err_64_bit_builtin_32_bit_tgt",

[f]="this builtin is only available on 64-bit targets",

[h]=k,

[b]="this builtin is only available on 64\\-bit targets",

[i]=a,

[g]=m,

[c]={"239eec732ebf",1428623896,"Add Clang support for remaining integer divide and permute instructions from ISA 2.06","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"},

[d]="err__Pragma_malformed",

[f]="_Pragma takes a parenthesized string literal",

[h]=k,

[b]="_Pragma takes a parenthesized string literal",

[i]=a,

[g]="Lexical or Preprocessor Issue",

[c]={I,1236199783,K,L},

[j]={{sc,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);"},{sc,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);"},{sc,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);"},{sc,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);"},{sc,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);"}},

[d]="err_abi_tag_on_redeclaration",

[f]="cannot add \'abi_tag\' attribute in a redeclaration",

[h]=k,

[b]="cannot add \'abi_tag\' attribute in a redeclaration",

[i]=a,

[g]=m,

[c]={"bf17ecf59a9b",1457537453,"[GCC] PR23529 Sema part of attrbute abi_tag support","[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"},

[j]={{p,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);"}},

[d]="err_abstract_type_in_decl",

[e]="%select{return|parameter|variable|field|instance variable|synthesized instance variable}0 type %1 is an abstract class",

[f]={{nil,nil,{{"return","parameter","variable","field","instance variable","synthesized instance variable"}," type B is an abstract class"}}},

[h]=k,

[b]="(?:return|parameter|variable|field|instance variable|synthesized instance variable) type (.*?) is an abstract class",

[i]=a,

[g]=m,

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

[j]={{t,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))) {"},{p,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))"},{p,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)) {"},{p,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))"},{p,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)) {"},{p,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)))"},{p,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))"},{p,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)) {"},{S,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();"},{S,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))"},{lb,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)) {"}},

[d]="err_access",

[e]="%1 is a %select{private|protected}0 member of %3",

[f]={{nil,nil,{"B is a ",{V,Y}," member of D"}}},

[h]=k,

[b]="(.*?) is a (?:private|protected) member of (.*?)",

[i]=a,

[g]=m,

[c]={Ob,1268716967,Fb,Gb},

[j]={{gb,1568,"Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{gb,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();"},{gb,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;"},{gb,1790,"Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, const SourceRange &Range, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << ObjectExpr->getSourceRange() << Range;"},{gb,1863,"Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair Found) {\n  // ...\n  Entity.setDiag(diag::err_access) << Ovl->getSourceRange();"},{gb,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);"}},

[d]="err_access_base_ctor",

[e]="%select{base class|inherited virtual base class}0 %1 has %select{private|protected}3 %select{default |copy |move |*ERROR* |*ERROR* |*ERROR*|}2constructor",

[f]={{nil,nil,{{"base class","inherited virtual base class"}," B has ",{V,Y}," ",{"default ","copy ","move ",a},"constructor"}}},

[h]=k,

[b]="(?:base class|inherited virtual base class) (.*?) has (?:private|protected) (?:default |copy |move |)constructor",

[i]=a,

[g]=m,

[c]={"80f00ff95d3b",1305054494,"Re-do R131114 without breaking code.","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"},

[j]={{gb,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);"}},

[d]="err_access_ctor",

[e]="calling a %select{private|protected}0 constructor of class %2",

[f]={{nil,nil,{"calling a ",{V,Y}," constructor of class C"}}},

[h]=k,

[b]="calling a (?:private|protected) constructor of class (.*?)",

[i]=a,

[g]=m,

[c]={Ob,1268716967,Fb,Gb},

[j]={{gb,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);"}},

[d]="err_access_decl",

[f]="ISO C++11 does not allow access declarations; use using declarations instead",

[h]=k,

[b]="ISO C\\+\\+11 does not allow access declarations; use using declarations instead",

[i]=a,

[g]=m,

[c]={"f026b600992d",1371089537,"In C++11, promote access declaration diagnostic from warning to error. There","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"},

[j]={{S,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 \");"}},

[d]="err_access_dtor",

[e]="calling a %select{private|protected}1 destructor of class %0",

[f]={{nil,nil,{"calling a ",{V,Y}," destructor of class A"}}},

[h]=k,

[b]="calling a (?:private|protected) destructor of class (.*?)",

[i]=a,

[g]=m,

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

[j]={{A,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);"}},

[d]="err_access_dtor_base",

[e]="base class %0 has %select{private|protected}1 destructor",

[f]={{nil,nil,{"base class A has ",{V,Y},vb}}},

[h]=k,

[b]="base class (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={Ob,1268716967,Fb,Gb},

[j]={{S,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));"}},

[d]="err_access_dtor_exception",

[e]="exception object of type %0 has %select{private|protected}1 destructor",

[f]={{nil,nil,{"exception object of type A has ",{V,Y},vb}}},

[h]=k,

[b]="exception object of type (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={"442612c2853f",1278542113,"Do not use CXXZeroValueInitExpr for class types. Instead, use","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"},

[j]={{A,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);"}},

[d]="err_access_dtor_field",

[e]="field of type %1 has %select{private|protected}2 destructor",

[f]={{nil,nil,{"field of type B has ",{V,Y},vb}}},

[h]=k,

[b]="field of type (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={Ob,1268716967,Fb,Gb},

[j]={{S,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);"}},

[d]="err_access_dtor_ivar",

[e]="instance variable of type %0 has %select{private|protected}1 destructor",

[f]={{nil,nil,{"instance variable of type A has ",{V,Y},vb}}},

[h]=k,

[b]="instance variable of type (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={"527786ea3a6a",1274322262,"Various small fixes for construction/destruction of Objective-C++","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"},

[j]={{S,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()));"}},

[d]="err_access_dtor_temp",

[e]="temporary of type %0 has %select{private|protected}1 destructor",

[f]={{nil,nil,{"temporary of type A has ",{V,Y},vb}}},

[h]=k,

[b]="temporary of type (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={"8e36d53e34be",1270600906,"Check access for the implicit calls to destructors that occur when we","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"},

[j]={{A,7334,"ExprResult Sema::MaybeBindToTemporary(Expr *E) {\n  // ...\n  if (Destructor) {\n    // ...\n    CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << E->getType());"},{A,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());"},{T,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);"},{T,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);"}},

[d]="err_access_dtor_var",

[e]="variable of type %1 has %select{private|protected}2 destructor",

[f]={{nil,nil,{"variable of type B has ",{V,Y},vb}}},

[h]=k,

[b]="variable of type (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={Ob,1268716967,Fb,Gb},

[j]={{S,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());"}},

[d]="err_access_dtor_vbase",

[e]="inherited virtual base class %1 has %select{private|protected}2 destructor",

[f]={{nil,nil,{"inherited virtual base class B has ",{V,Y},vb}}},

[h]=k,

[b]="inherited virtual base class (.*?) has (?:private|protected) destructor",

[i]=a,

[g]=m,

[c]={Ob,1268716967,Fb,Gb},

[j]={{S,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) {"},{S,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);"}},

[d]="err_access_field_ctor",

[e]="field of type %0 has %select{private|protected}2 %select{default |copy |move |*ERROR* |*ERROR* |*ERROR* |}1constructor",

[f]={{nil,nil,{"field of type A has ",{V,Y}," ",{"default ","copy ","move ",a},"constructor"}}},

[h]=k,

[b]="field of type (.*?) has (?:private|protected) (?:default |copy |move |)constructor",

[i]=a,

[g]=m,

[c]={"80f00ff95d3b",1305054494,"Re-do R131114 without breaking code.","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"},

[j]={{gb,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);"}},

[d]="err_access_friend_function",

[e]="friend function %1 is a %select{private|protected}0 member of %3",

[f]={{nil,nil,{"friend function B is a ",{V,Y}," member of D"}}},

[h]=k,

[b]="friend function (.*?) is a (?:private|protected) member of (.*?)",

[i]=a,

[g]=m,

[c]={"a0a96895501e",1344568535,"Check access to friend declarations.  There\'s a number of different","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"},

[j]={{gb,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());"}},

[d]="err_access_lambda_capture",

[e]="capture of variable \'%0\' as type %1 calls %select{private|protected}3 %select{default |copy |move |*ERROR* |*ERROR* |*ERROR* |}2constructor",

[f]={{nil,nil,{"capture of variable \'A\' as type B calls ",{V,Y}," ",{"default ","copy ","move ",a},"constructor"}}},

[h]=k,

[b]="capture of variable \'(.*?)\' as type (.*?) calls (?:private|protected) (?:default |copy |move |)constructor",

[i]=a,

[g]="Lambda Issue",

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

[j]={{gb,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);"}},

[d]="err_access_specifier_interface",

[e]="interface types cannot specify \'%select{private|protected}0\' access",

[f]={{nil,nil,{"interface types cannot specify \'",{V,Y},"\' access"}}},

[h]=k,

[b]="interface types cannot specify \'(?:private|protected)\' access",

[i]=a,

[g]=F,

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

[j]={{P,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);"}},

[d]="err_addr_ovl_ambiguous",

[e]="address of overloaded function %0 is ambiguous",

[f]="address of overloaded function A is ambiguous",

[h]=k,

[b]="address of overloaded function (.*?) is ambiguous",

[i]=a,

[g]=m,

[c]={"b257e4fff8a9",1247096032,"Implement the simple form of overload resolution used when taking the","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"},

[j]={{fb,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);"},{fb,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();"},{fb,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();"}},

[d]="err_addr_ovl_no_qualifier",

[e]="cannot form member pointer of type %0 without \'&\' and class name",

[f]="cannot form member pointer of type A without \'&\' and class name",

[h]=k,

[b]="cannot form member pointer of type (.*?) without \'&\' and class name",

[i]=a,

[g]=m,

[c]={"24d189484b44",1282690359,"When trying to resolve the address of an overloaded expression,","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"},

[j]={{fb,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();"}},

[d]="err_addr_ovl_no_viable",

[e]="address of overloaded function %0 does not match required type %1",

[f]="address of overloaded function A does not match required type B",

[h]=k,

[b]="address of overloaded function (.*?) does not match required type (.*?)",

[i]=a,

[g]=m,

[c]={"064fdb2fe844",1271286681,"Always diagnose and complain about problems in","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"},

[j]={{fb,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();"}},

[d]="err_addr_ovl_not_func_ptrref",

[e]="address of overloaded function %0 cannot be converted to type %1",

[f]="address of overloaded function A cannot be converted to type B",

[h]=k,

[b]="address of overloaded function (.*?) cannot be converted to type (.*?)",

[i]=a,

[g]=m,

[c]={"064fdb2fe844",1271286681,"Always diagnose and complain about problems in","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"},

[j]={{fb,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; }"}}

[d]="err_address_of_function_with_pass_object_size_params",

[e]="cannot take address of function %0 because parameter %1 has pass_object_size attribute",

[f]="cannot take address of function A because parameter B has pass_object_size attribute",

[h]=k,

[b]="cannot take address of function (.*?) because parameter (.*?) has pass_object_size attribute",

[i]=a,

[g]=m,

[c]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang.","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"},

[j]={{fb,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;"}},

[d]="err_address_of_label_outside_fn",

[f]="use of address-of-label extension outside of a function body",

[h]=k,

[b]="use of address\\-of\\-label extension outside of a function body",

[i]=a,

[g]=F,

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

[j]={{xb,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));"}},

[d]={{nil,E,"err_address_space_mismatch_templ_inst"}},

[e]={{nil,E,"conflicting address space qualifiers are provided between types %0 and %1"}},

[f]={{nil,E,"conflicting address space qualifiers are provided between types A and B"}},

[h]=k,

[b]="conflicting address space qualifiers are provided between types (.*?) and (.*?)",

[i]=a,

[g]={{nil,E,m}},

[c]={"12e3a8af81da",1544029342,"[OpenCL] Diagnose conflicting address spaces in templates.","[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"},

[d]="err_address_space_qualified_delete",

[e]="\'delete\' cannot delete objects of type %0 in address space \'%1\'",

[f]="\'delete\' cannot delete objects of type A in address space \'B\'",

[h]=k,

[b]="\'delete\' cannot delete objects of type (.*?) in address space \'(.*?)\'",

[i]=a,

[g]=m,

[c]={"39d1a0973db9",1302896780,"Forbid the use of C++ new/delete to allocate/free objects within an","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"},

[j]={{A,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();"}},

[d]="err_address_space_qualified_new",

[e]="\'new\' cannot allocate objects of type %0 in address space \'%1\'",

[f]="\'new\' cannot allocate objects of type A in address space \'B\'",

[h]=k,

[b]="\'new\' cannot allocate objects of type (.*?) in address space \'(.*?)\'",

[i]=a,

[g]=m,

[c]={"39d1a0973db9",1302896780,"Forbid the use of C++ new/delete to allocate/free objects within an","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"},

[j]={{A,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();"}},

[d]={{nil,r,"err_addrof_function_constraints_not_satisfied"}},

[e]={{nil,r,"cannot take address of function %0 because its constraints are not satisfied"}},

[f]={{nil,r,"cannot take address of function A because its constraints are not satisfied"}},

[h]=k,

[b]="cannot take address of function (.*?) because its constraints are not satisfied",

[i]=a,

[g]={{nil,r,m}},

[c]={"349636d2bfc3",1575555459,"Implement VectorType conditional operator GNU extension.","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"},

[j]={{fb,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;"}}

[d]="err_addrof_function_disabled_by_enable_if_attr",

[e]="cannot take address of function %0 becuase it has one or more non-tautological enable_if conditions",

[f]="cannot take address of function A becuase it has one or more non-tautological enable_if conditions",

[h]=k,

[b]="cannot take address of function (.*?) because it has one or more non\\-tautological enable_if conditions",

[i]=a,

[g]=m,

[c]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang.","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"},

[j]={{fb,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;"}},

[d]={{nil,z,"err_aix_attr_unsupported_tls_model"}},

[e]={{nil,z,"TLS model \'%0\' is not yet supported on AIX"}},

[f]={{nil,z,"TLS model \'A\' is not yet supported on AIX"}},

[h]=k,

[b]="TLS model \'(.*?)\' is not yet supported on AIX",

[i]=a,

[g]={{nil,z,m}},

[c]={"3dbcea8b957a",1615397021,"Reland [clang] Check unsupported types in expressions","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"},

[d]={{nil,z,"err_aix_unsupported_tls_model"}},

[e]={{nil,z,"TLS model \'%0\' is not yet supported on AIX"}},

[f]={{nil,z,"TLS model \'A\' is not yet supported on AIX"}},

[h]=k,

[b]="TLS model \'(.*?)\' is not yet supported on AIX",

[i]=a,

[g]={{nil,z,W}},

[c]={"0687578728ea",1610286626,"[C++20][Modules][HU 2/5] Support searching Header Units in user or system search paths.","[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"},

[j]={{eb,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;"}},

[d]="err_alias_after_tentative",

[e]="alias definition of %0 after tentative definition",

[f]="alias definition of A after tentative definition",

[h]=k,

[b]="alias definition of (.*?) after tentative definition",

[i]=a,

[g]=m,

[c]={"d53ffa0a70d8",1382477943,"Treat aliases as definitions.","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"},

[j]={{p,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;"}},

[d]="err_alias_declaration_not_identifier",

[f]="name defined in alias declaration must be an identifier",

[h]=k,

[b]="name defined in alias declaration must be an identifier",

[i]=a,

[g]=F,

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

[j]={{P,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);"},{P,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));"},{P,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());"}},

[d]="err_alias_declaration_pack_expansion",

[f]="alias declaration cannot be a pack expansion",

[h]=k,

[b]="alias declaration cannot be a pack expansion",

[i]=a,

[g]=F,

[c]={"22a250cd5d8e",1482120533,"[c++1z] P0195R2: Support pack-expansion of using-declarations.","[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"},

[j]={{P,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));"}}

[d]="err_alias_declaration_specialization",

[e]="%select{partial specialization|explicit specialization|explicit instantiation}0 of alias templates is not permitted",

[f]={{nil,nil,{{"partial specialization","explicit specialization","explicit instantiation"}," of alias templates is not permitted"}}},

[h]=k,

[b]="(?:partial specialization|explicit specialization|explicit instantiation) of alias templates is not permitted",

[i]=a,

[g]=F,

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

[j]={{P,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;"}},

[d]="err_alias_is_definition",

[e]="definition %0 cannot also be an %select{alias|ifunc}1",

[f]={{nil,nil,{"definition A cannot also be an ",{"alias","ifunc"}}}},

[h]=k,

[b]="definition (.*?) cannot also be an (?:alias|ifunc)",

[i]=a,

[g]=m,

[c]={"2dc814664385",1421658028,"Sema: Variable definitions cannot be __attribute__((alias))","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"},

[j]={{p,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;"},{p,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;"},{p,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;"},{n,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;"},{n,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;"},{n,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;"},{n,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;"}},

[d]="err_alias_not_supported_on_darwin",

[e]={{nil,B,"aliases are not supported on darwin"},{D,nil,"only weak aliases are supported on darwin"}},

[f]={{nil,B,"aliases are not supported on darwin"},{D,nil,"only weak aliases are supported on darwin"}},

[h]=k,

[b]="aliases are not supported on darwin",

[i]=a,

[g]=m,

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

[d]="err_alias_not_supported_on_nvptx",

[f]="CUDA does not support aliases",

[h]=k,

[b]="CUDA does not support aliases",

[i]=a,

[g]=m,

[c]={"a8f0254bc1a4",1453584490,"[CUDA] Reject the alias attribute in CUDA device code.","[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"},

[d]="err_alias_template_extra_headers",

[f]="extraneous template parameter list in alias template declaration",

[h]=k,

[b]="extraneous template parameter list in alias template declaration",

[i]=a,

[g]=m,

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

[j]={{S,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());"}},

[d]="err_alias_to_undefined",

[e]="%select{alias|ifunc}0 must point to a defined %select{variable or |}1function",

[f]={{nil,nil,{{"alias","ifunc"}," must point to a defined ",{"variable or ",a},"function"}}},

[h]=k,

[b]="(?:alias|ifunc) must point to a defined (?:variable or |)function",

[i]=a,

[g]={{nil,E,W},{Lb,nil,m}},

[c]={"0fad0d772433",1382449866,"This patch causes clang to reject alias attributes that point to undefined","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"},

[d]="err_align_value_attribute_argument_not_int",

[f]="\'align_value\' attribute requires integer constant",

[h]=k,

[b]="\'align_value\' attribute requires integer constant",

[i]=a,

[g]=m,

[c]={"1b0d24e03abf",1412284885,"Initial support for the align_value attribute","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"},

[d]="err_alignas_attribute_wrong_decl_type",

[e]={{nil,u,"%0 attribute cannot be applied to %select{a function parameter|a variable with \'register\' storage class|a \'catch\' variable|a bit-field|an enumeration}1"},{v,nil,"%0 attribute cannot be applied to a %select{function parameter|variable with \'register\' storage class|\'catch\' variable|bit-field}1"}},

[f]={{nil,u,{"A attribute cannot be applied to ",{"a function parameter","a variable with \'register\' storage class","a \'catch\' variable","a bit-field","an enumeration"}}},{v,nil,{"A attribute cannot be applied to a ",{"function parameter","variable with \'register\' storage class","\'catch\' variable","bit-field"}}}},

[h]=k,

[b]="(.*?) attribute cannot be applied to (?:a function parameter|a variable with \'register\' storage class|a \'catch\' variable|a bit\\-field|an enumeration)",

[i]=a,

[g]=m,

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

[d]="err_alignas_mismatch",

[e]="redeclaration has different alignment requirement (%1 vs %0)",

[f]="redeclaration has different alignment requirement (B vs A)",

[h]=k,

[b]="redeclaration has different alignment requirement \\((.*?) vs (.*?)\\)",

[i]=a,

[g]=m,

[c]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of","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"},

[j]={{p,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();"}},

[d]="err_alignas_missing_on_definition",

[e]="%0 must be specified on definition if it is specified on any declaration",

[f]="A must be specified on definition if it is specified on any declaration",

[h]=k,

[b]="(.*?) must be specified on definition if it is specified on any declaration",

[i]=a,

[g]=m,

[c]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of","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"},

[j]={{p,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;"},{p,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;"}},

[d]="err_alignas_underaligned",

[e]="requested alignment is less than minimum alignment of %1 for type %0",

[f]="requested alignment is less than minimum alignment of B for type A",

[h]=k,

[b]="requested alignment is less than minimum alignment of (.*?) for type (.*?)",

[i]=a,

[g]=m,

[c]={"848e1f19605a",1359706328,"Implement [dcl.align]p5 and C11 6.7.5/4: alignas cannot underalign.","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"},

[d]={{nil,C,"err_aligned_allocation_unavailable"}},

[e]={{nil,s,"aligned %select{allocation|deallocation}0 function of type \'%1\' is %select{only|not}4 available on %2%select{ %3 or newer|}4"},{Ib,C,"aligned %select{allocation|deallocation}0 function of type \'%1\' is only available on %2 %3 or newer"}},

[f]={{nil,s,{"aligned ",{"allocation","deallocation"}," function of type \'B\' is ",{"only","not"}," available on C",{" D or newer",a}}},{Ib,C,{"aligned ",{"allocation","deallocation"}," function of type \'B\' is only available on C D or newer"}}},

[h]=k,

[b]="aligned (?:allocation|deallocation) function of type \'(.*?)\' is (?:only|not) available on (.*?)(?: (.*?) or newer|)",

[i]=a,

[g]={{nil,C,m}},

[c]={"e5015abf185b",1533337957,"[Preprocessor] Allow libc++ to detect when aligned allocation is unavailable.","[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"},

[j]={{A,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();"}},

[d]="err_aligned_attribute_argument_not_int",

[f]="\'aligned\' attribute requires integer constant",

[h]=k,

[b]="\'aligned\' attribute requires integer constant",

[i]=a,

[g]=m,

[c]={"e2b3744890f6",1336171132,"Move Sema::VerifyIntegerConstantExpression() and","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"},

[d]="err_alignment_dependent_typedef_name",

[f]="requested alignment is dependent but declaration is not dependent",

[h]=k,

[b]="requested alignment is dependent but declaration is not dependent",

[i]=a,

[g]=m,

[c]={"26a1e0ef760a",1428374229,"[Sema] Don\'t permit dependent alignments on non-dependent typedef-names","[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"},

[d]="err_alignment_not_power_of_two",

[f]="requested alignment is not a power of 2",

[h]=k,

[b]="requested alignment is not a power of 2",

[i]=a,

[g]=m,

[c]={"bcc06085a894",1410130694,"Add __builtin_assume and __builtin_assume_aligned using @llvm.assume.","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"},

[d]="err_alignment_too_big",

[e]="requested alignment must be %0 or smaller",

[f]="requested alignment must be A or smaller",

[h]=k,

[b]="requested alignment must be (.*?) or smaller",

[i]=a,

[g]=m,

[c]={"5116993f8ea7",1477892268,"Add support for __builtin_alloca_with_align","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"},

[d]="err_alignment_too_small",

[e]="requested alignment must be %0 or greater",

[f]="requested alignment must be A or greater",

[h]=k,

[b]="requested alignment must be (.*?) or greater",

[i]=a,

[g]=m,

[c]={"5116993f8ea7",1477892268,"Add support for __builtin_alloca_with_align","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"},

[d]="err_alignof_member_of_incomplete_type",

[f]="invalid application of \'alignof\' to a field of a class still being defined",

[h]=k,

[b]="invalid application of \'alignof\' to a field of a class still being defined",

[i]=a,

[g]=m,

[c]={"768439eb2e7e",1367826034,"Require the containing type to be complete when we see","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"},

[j]={{ab,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();"}},

[d]="err_allocation_of_abstract_type",

[e]="allocating an object of abstract class type %0",

[f]="allocating an object of abstract class type A",

[h]=k,

[b]="allocating an object of abstract class type (.*?)",

[i]=a,

[g]=m,

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

[j]={{ib,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)) {"},{A,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))"},{A,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))"},{T,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);"}},

[d]="err_altivec_empty_initializer",

[f]="expected initializer",

[h]=k,

[b]="expected initializer",

[i]=a,

[g]=m,

[c]={"a96114ed087b",1249840544,"AltiVec-style vector initializer syntax, vec4 a = (vec4)(a, b, c, d);","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"},

[j]={{ab,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);"}}

[d]="err_ambiguous_base_to_derived_cast",

[e]="ambiguous cast from base %0 to derived %1:%2",

[f]="ambiguous cast from base A to derived B:C",

[h]=k,

[b]="ambiguous cast from base (.*?) to derived (.*?)\\:(.*?)",

[i]=a,

[g]=m,

[c]={w,1237025389,x,y},

[j]={{ib,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;"}},

[d]="err_ambiguous_delete_operand",

[e]="ambiguous conversion of delete expression of type %0 to a pointer",

[f]="ambiguous conversion of delete expression of type A to a pointer",

[h]=k,

[b]="ambiguous conversion of delete expression of type (.*?) to a pointer",

[i]=a,

[g]=m,

[c]={"c34c179f4bcd",1253035307,"Perform overload resolution when selecting a pointer conversion","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"},

[j]={{A,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; }"}},

[d]="err_ambiguous_derived_to_base_conv",

[e]="ambiguous conversion from derived class %0 to base class %1:%2",

[f]="ambiguous conversion from derived class A to base class B:C",

[h]=k,

[b]="ambiguous conversion from derived class (.*?) to base class (.*?)\\:(.*?)",