Module:ClangDiags/DiagsLongData0: Difference between revisions

local b="regex3";

local c="prefix";

local d="commit";

local e="type";

local f="title";

local g="message";

local h="category";

local i="regex1";

local j="regex2";

local l="error: ";

local m="(?:error|fatal error)\\: ";

local n="Error";

local o="Semantic Issue";

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

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

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

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

local t="Update tablegen diagnostic files to be in sync with the def files.";

local u="5a8987ca5113";

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

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

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

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

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

local A="b1c4d5507fad";

local B="Parse Issue";

local C="Inline Assembly Issue";

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

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

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

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

local H="31168b077c36";

local I="clang/lib/Sema/SemaDeclObjC.cpp";

local J="Automatic Reference Counting.";

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

local L="ARC Semantic Issue";

local M="Implement P2361 Unevaluated string literals";

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

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

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

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

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

local T="14f6bfcb52e7";

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

local V="[WebAssembly] Improve clang diagnostics for wasm attributes";

local W="931fcd3ba011";

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

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

local bb="constexpr: semantic checking for constexpr functions and constructors. Based in";

local cb="[OPENMP]Fix PR49366: crash on VLAs in task untied regions.";

local db="f9c3310d32c6";

local eb="Let clang atomic builtins fetch add/sub support floating point types";

local gb="Lexical or Preprocessor Issue";

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

local ib="2a7d481faf54";

local jb="ARC Restrictions";

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

local mb="Emit !callback metadata and introduce the callback attribute";

local nb="ac991bbb4456";

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

local qb="1064d7ef2992";

local rb="AMDGPU: Teach toolchain to link rocm device libs";

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

local tb="4593e4131aff";

local ub="f881267db9a9";

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

local wb="30482bc78659";

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

local yb="Mass-rename the handful of error_* diagnostics to err_*.";

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

local Ab="ARC Weak References";

local Bb="fatal error\\: ";

local Cb="clang/lib/Sema/SemaTemplate.cpp";

local Db="[ObjC] Implement @available in the Parser and AST";

local Eb="Fatal";

local Fb="fatal error: ";

local Gb="29099ded0c15";

local Hb="clang/lib/Parse/ParseTemplate.cpp";

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

local Jb="clang/lib/Parse/Parser.cpp";

local Kb="Reland [clang] Check unsupported types in expressions";

local Lb="3dbcea8b957a";

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

[c]="warning: ",

[e]="Warning",

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

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

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

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

[h]=gb,

[d]={A,1236199783,z},

[k]={{zb,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  Slash:\n    // See if we have optional whitespace characters between the slash and\n    // newline.\n    if (unsigned EscapedNewLineSize = getEscapedNewLineSize(Ptr)) {\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);"},{zb,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  while (true) {\n    if (C != 0) {\n      // If there was space between the backslash and newline, warn about it.\n      if (HasSpace && !isLexingRawMode())\n        Diag(EscapePtr, diag::backslash_newline_space);"},{zb,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  // 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);"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"51738f834ed9",1524773686,"[X86] Make __builtin_ia32_readeflags_u32 and __builtin_ia32_writeeflags_u32 only available on 32-bit..."},

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

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"239eec732ebf",1428623896,"Add Clang support for remaining integer divide and permute instructions from ISA 2.06"},

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

[e]=n,

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

[i]=m,

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

[d]={A,1236199783,z},

[k]={{Ib,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  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,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  if (!tok::isStringLiteral(Tok.getKind())) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,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  if (Tok.isNot(tok::r_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,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  if (Invalid) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"},{Ib,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  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaLoc, diag::err__Pragma_malformed);"}}

[e]=n,

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

[i]=m,

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

[d]={"bf17ecf59a9b",1457537453,"[GCC] PR23529 Sema part of attrbute abi_tag support"},

[k]={{q,3263,"/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.\nvoid Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK) {\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    } else {\n      Diag(NewAbiTagAttr->getLocation(), diag::err_abi_tag_on_redeclaration);"}}

[f]="... type A is an abstract class",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"576cc6f725a8",1237753097,"Disallow abstract types where appropriate."},

[k]={{s,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  for (ParmVarDecl *Param : Parameters) {\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))) {"},{q,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  if (!VDecl->getType()->isDependentType()) {\n    if (RequireNonAbstractType(VDecl->getLocation(), VDecl->getType(), diag::err_abstract_type_in_decl, AbstractVariableType))"},{q,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  if (RequireNonAbstractType(VD->getLocation(), Ty, diag::err_abstract_type_in_decl, AbstractVariableType)) {"},{q,13776,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    case VarDecl::DeclarationOnly:\n      if (!Type->isDependentType() && !Var->isInvalidDecl() && RequireNonAbstractType(Var->getLocation(), Type, diag::err_abstract_type_in_decl, AbstractVariableType))"},{q,13868,"void Sema::ActOnUninitializedDecl(Decl *RealDecl) {\n  if (VarDecl *Var = dyn_cast<VarDecl>(RealDecl)) {\n    if (RequireNonAbstractType(Var->getLocation(), Type, diag::err_abstract_type_in_decl, AbstractVariableType)) {"},{q,15350,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\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)))"},{q,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  if (!InvalidDecl && RequireNonAbstractType(Loc, T, diag::err_abstract_type_in_decl, AbstractFieldType))"},{q,18876,"void Sema::ActOnFields(Scope *S, SourceLocation RecLoc, Decl *EnclosingDecl, ArrayRef<Decl *> Fields, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &Attrs) {\n  for (ArrayRef<Decl *>::iterator i = Fields.begin(), end = Fields.end(); i != end; ++i) {\n    if (FDTy->isFunctionType()) {\n    } else if (FDTy->isIncompleteArrayType() && (Record || isa<ObjCContainerDecl>(EnclosingDecl))) {\n    } else if (!FDTy->isDependentType() && RequireCompleteSizedType(FD->getLocation(), FD->getType(), diag::err_field_incomplete_or_sizeless)) {\n    } else if (const RecordType *FDTTy = FDTy->getAs<RecordType>()) {\n      if (isa<ObjCContainerDecl>(EnclosingDecl) && RequireNonAbstractType(FD->getLocation(), FD->getType(), diag::err_abstract_type_in_decl, AbstractIvarType)) {"},{v,6098,"#include \"clang/AST/TypeLocNodes.def\"\n  CheckPolymorphic(PointerTypeLoc) CheckPolymorphic(ReferenceTypeLoc) CheckPolymorphic(MemberPointerTypeLoc) CheckPolymorphic(BlockPointerTypeLoc) CheckPolymorphic(AtomicTypeLoc)\n    // It matched; do some magic.\n    // FIXME: These should be at most warnings. See P0929R2, CWG1640, CWG1646.\n    if (Sel == Sema::AbstractArrayType) {\n    } else {\n      Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl) << Sel << T << TL.getSourceRange();"},{v,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  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  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    if (!Ivar) {\n      if (RequireNonAbstractType(PropertyIvarLoc, PropertyIvarType, diag::err_abstract_type_in_decl, AbstractSynthesizedIvarType)) {"}}

[f]="A is a ... member of B",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={qb,1268716967,sb},

[k]={{S,1568,"Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{S,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  Entity.setDiag(diag::err_access) << E->getSourceRange();"},{S,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  if (Diagnose)\n    Entity.setDiag(diag::err_access) << PlacementRange;"},{S,1790,"Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, const SourceRange &Range, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << ObjectExpr->getSourceRange() << Range;"},{S,1863,"Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair Found) {\n  Entity.setDiag(diag::err_access) << Ovl->getSourceRange();"},{S,1920,"/// Checks access to all the declarations in the given result set.\nvoid Sema::CheckLookupAccess(const LookupResult &R) {\n  for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) {\n    if (I.getAccess() != AS_public) {\n      Entity.setDiag(diag::err_access);"}}

[f]="... A has ... ...constructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"80f00ff95d3b",1305054494,"Re-do R131114 without breaking code."},

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

[f]="calling a ... constructor of class A",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={qb,1268716967,sb},

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

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"f026b600992d",1371089537,"In C++11, promote access declaration diagnostic from warning to error. There"},

[k]={{v,12068,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\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 \");"}}

[f]="calling a ... destructor of class A",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"fa7781384ebb",1296575411,"Implement access checking for the \"delete\" operator. Fixes PR9050,"},

[k]={{x,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  if (!Ex.get()->isTypeDependent()) {\n    if (PointeeRD) {\n      if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) {\n        CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, PDiag(diag::err_access_dtor) << PointeeElem);"}}

[f]="base class A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={qb,1268716967,sb},

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

[f]="exception object of type A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"442612c2853f",1278542113,"Do not use CXXZeroValueInitExpr for class types. Instead, use"},

[k]={{x,1033,"/// CheckCXXThrowOperand - Validate the operand of a throw.\nbool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, QualType ExceptionObjectTy, Expr *E) {\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      CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_exception) << Ty);"}}

[f]="field of type A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={qb,1268716967,sb},

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

[f]="instance variable of type A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"527786ea3a6a",1274322262,"Various small fixes for construction/destruction of Objective-C++"},

[k]={{v,18491,"/// SetIvarInitializers - This routine builds initialization ASTs for the\n/// Objective-C implementation whose ivars need be initialized.\nvoid Sema::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) {\n  if (ObjCInterfaceDecl *OID = ObjCImplementation->getClassInterface()) {\n    for (unsigned i = 0; i < ivars.size(); i++) {\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        if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) {\n          CheckDestructorAccess(Field->getLocation(), Destructor, PDiag(diag::err_access_dtor_ivar) << Context.getBaseElementType(Field->getType()));"}}

[f]="temporary of type A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"8e36d53e34be",1270600906,"Check access for the implicit calls to destructors that occur when we"},

[k]={{x,7334,"ExprResult Sema::MaybeBindToTemporary(Expr *E) {\n  if (Destructor) {\n    CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << E->getType());"},{x,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  // 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    CheckDestructorAccess(Bind->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << Bind->getType());"},{E,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  SemaRef.CheckDestructorAccess(Loc, Destructor, SemaRef.PDiag(diag::err_access_dtor_temp) << ElementType);"},{E,8929,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  for (step_iterator Step = step_begin(), StepEnd = step_end(); Step != StepEnd; ++Step) {\n    case SK_UserConversion: {\n      if (shouldBindAsTemporary(Entity))\n      else if (CreatedObject && shouldDestroyEntity(Entity)) {\n        if (const RecordType *Record = T->getAs<RecordType>()) {\n          S.CheckDestructorAccess(CurInit.get()->getBeginLoc(), Destructor, S.PDiag(diag::err_access_dtor_temp) << T);"}}

[f]="variable of type A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={qb,1268716967,sb},

[k]={{v,15869,"void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) {\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    CheckDestructorAccess(VD->getLocation(), Destructor, PDiag(diag::err_access_dtor_var) << VD->getDeclName() << VD->getType());"}}

[f]="inherited virtual base class A has ... destructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={qb,1268716967,sb},

[k]={{v,5885,"void Sema::MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {\n  // Virtual bases.\n  for (const auto &VBase : ClassDecl->vbases()) {\n    if (CheckDestructorAccess(ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), Context.getTypeDeclType(ClassDecl)) == AR_accessible) {"},{v,5891,"void Sema::MarkVirtualBaseDestructorsReferenced(SourceLocation Location, CXXRecordDecl *ClassDecl, llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {\n  // Virtual bases.\n  for (const auto &VBase : ClassDecl->vbases()) {\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);"}}

[f]="field of type A has ... ...constructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"80f00ff95d3b",1305054494,"Re-do R131114 without breaking code."},

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

[f]="friend function A is a ... member of B",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"a0a96895501e",1344568535,"Check access to friend declarations.  There\'s a number of different"},

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

[f]="capture of variable \'A\' as type B calls ... ...constructor",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]="Lambda Issue",

[d]={"19666fb1aa7d",1329325046,"Introduce a new initialization entity for lambda captures, and"},

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

[f]="interface types cannot specify \'...\' access",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=B,

[d]={"db632ac004ae",1348558359,"Fix for r163013 regression and further __interface enhancement."},

[k]={{K,3403,"Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(AccessSpecifier &AS, ParsedAttributes &AccessAttrs, DeclSpec::TST TagType, Decl *TagDecl) {\n  case tok::kw_protected: {\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);"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"b257e4fff8a9",1247096032,"Implement the simple form of overload resolution used when taking the"},

[k]={{Q,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  void EliminateAllExceptMostSpecializedTemplate() {\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);"},{Q,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  void ComplainMultipleMatchesFound() const {\n    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous) << OvlExpr->getName() << OvlExpr->getSourceRange();"},{Q,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  for (UnresolvedSetIterator I = ovl->decls_begin(), E = ovl->decls_end(); I != E; ++I) {\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();"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"24d189484b44",1282690359,"When trying to resolve the address of an overloaded expression,"},

[k]={{Q,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  void ComplainIsInvalidFormOfPointerToMemberFunction() const {\n    S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier) << TargetType << OvlExpr->getSourceRange();"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"064fdb2fe844",1271286681,"Always diagnose and complain about problems in"},

[k]={{Q,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  void ComplainNoMatchesFound() const {\n    S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable) << OvlExpr->getName() << TargetFunctionType << OvlExpr->getSourceRange();"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"064fdb2fe844",1271286681,"Always diagnose and complain about problems in"},

[k]={{Q,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  void ComplainOfInvalidConversion() const { S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref) << OvlExpr->getName() << TargetType; }"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang."},

[k]={{Q,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  if (Complain) {\n    if (InOverloadResolution)\n    else\n      S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params) << FD << ParamNo;"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=B,

[d]={"9ba479bd2c2c",1298063799,"fix rdar://9024687, a crash on invalid that we used to silently ignore."},

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

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

[c]=l,

[e]=n,

[g]="conflicting address space qualifiers are provided between types %0 and %1",

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

[b]=a,

[h]=o,

[d]={"12e3a8af81da",1544029342,"[OpenCL] Diagnose conflicting address spaces in templates."}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"39d1a0973db9",1302896780,"Forbid the use of C++ new/delete to allocate/free objects within an"},

[k]={{x,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  if (!Ex.get()->isTypeDependent()) {\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();"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"39d1a0973db9",1302896780,"Forbid the use of C++ new/delete to allocate/free objects within an"},

[k]={{x,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  else if (AllocType->isReferenceType())\n  else if (!AllocType->isDependentType() && RequireCompleteSizedType(Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))\n  else if (AllocType->isVariablyModifiedType())\n  else if (AllocType.getAddressSpace() != LangAS::Default && !getLangOpts().OpenCLCPlusPlus)\n    return Diag(Loc, diag::err_address_space_qualified_new) << AllocType.getUnqualifiedType() << AllocType.getQualifiers().getAddressSpaceAttributePrintValue();"}}

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

[c]=l,

[e]=n,

[g]="cannot take address of function %0 because its constraints are not satisfied",

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

[b]=a,

[h]=o,

[d]={"349636d2bfc3",1575555459,"Implement VectorType conditional operator GNU extension."},

[k]={{Q,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  if (FD->getTrailingRequiresClause()) {\n    if (!Satisfaction.IsSatisfied) {\n      if (Complain) {\n        if (InOverloadResolution) {\n        } else\n          S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied) << FD;"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang."},

[k]={{Q,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      else\n        S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;"}}

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

[c]=l,

[e]=n,

[g]="TLS model \'%0\' is not yet supported on AIX",

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

[b]=a,

[h]=o,

[d]={Lb,1615397021,Kb},

[k]={{p,2044,"static void handleTLSModelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.Context.getTargetInfo().getTriple().isOSAIX() && Model != \"global-dynamic\" && Model != \"local-exec\") {\n    S.Diag(LiteralLoc, diag::err_aix_attr_unsupported_tls_model) << Model;"}}

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

[c]=l,

[e]=n,

[g]="TLS model \'%0\' is not yet supported on AIX",

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

[b]=a,

[h]=a,

[d]={"0687578728ea",1610286626,"[C++20][Modules][HU 2/5] Support searching Header Units in user or system search paths."},

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

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"d53ffa0a70d8",1382477943,"Treat aliases as definitions."},

[k]={{q,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  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {\n      if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {\n      } else {\n        unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == VarDecl::TentativeDefinition ? diag::err_alias_after_tentative : diag::err_redefinition;"}}

[e]=n,

[b]=a,

[h]=B,

[d]={"dda56e4b4a9c",1302877477,"Support for C++11 (non-template) alias declarations."},

[k]={{K,905,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\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);"},{K,910,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\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));"},{K,915,"Decl *Parser::ParseAliasDeclarationAfterDeclarator(const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, UsingDeclarator &D, SourceLocation &DeclEnd, AccessSpecifier AS, ParsedAttributes &Attrs, Decl **OwnedType) {\n  // Name must be an identifier.\n  if (D.Name.getKind() != UnqualifiedIdKind::IK_Identifier) {\n  } else if (D.TypenameLoc.isValid())\n  else if (D.SS.isNotEmpty())\n    Diag(D.SS.getBeginLoc(), diag::err_alias_declaration_not_identifier) << FixItHint::CreateRemoval(D.SS.getRange());"}}

[e]=n,

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

[i]=m,

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

[d]={"22a250cd5d8e",1482120533,"[c++1z] P0195R2: Support pack-expansion of using-declarations."},

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

[f]="... of alias templates is not permitted",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=B,

[d]={"3f1b5d077b7e",1304632627,"Implement support for C++0x alias templates."},

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

[f]="definition A cannot also be an ...",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"2dc814664385",1421658028,"Sema: Variable definitions cannot be __attribute__((alias))"},

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

[e]=n,

[b]=a,

[h]=o,

[d]={"0017c5fa92ad",1291735403,"Fix PR8720 by printing an error message with a substring that the gcc testsuite searches for."},

[k]={{p,1993,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.Context.getTargetInfo().getTriple().isOSDarwin()) {\n    S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_darwin);"}}

[e]=n,

[b]=a,

[h]=o,

[d]={"a8f0254bc1a4",1453584490,"[CUDA] Reject the alias attribute in CUDA device code."},

[k]={{p,1997,"static void handleAliasAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.Context.getTargetInfo().getTriple().isNVPTX()) {\n    S.Diag(AL.getLoc(), diag::err_alias_not_supported_on_nvptx);"}}

[e]=n,

[b]=a,

[h]=o,

[d]={"3f1b5d077b7e",1304632627,"Implement support for C++0x alias templates."},

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

[f]="... must point to a defined ...function",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=a,

[d]={"0fad0d772433",1382449866,"This patch causes clang to reject alias attributes that point to undefined"},

[k]={{"clang/lib/CodeGen/CodeGenModule.cpp",578,"static bool checkAliasedGlobal(DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) {\n  if (GV->isDeclaration()) {\n    Diags.Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;"},{"clang/lib/CodeGen/CodeGenModule.cpp",602,"static bool checkAliasedGlobal(DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) {\n  if (IsIFunc) {\n    if (!F) {\n      Diags.Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;"}}

[e]=n,

[b]=a,

[h]=o,

[d]={"1b0d24e03abf",1412284885,"Initial support for the align_value attribute"},

[k]={{p,4331,"void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {\n  if (!E->isValueDependent()) {\n    ExprResult ICE = VerifyIntegerConstantExpression(E, &Alignment, diag::err_align_value_attribute_argument_not_int);"}}

[f]="A attribute cannot be applied to ...",

[c]=l,

[e]=n,

[g]="%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",

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

[b]=a,

[h]=o,

[d]={"1dba27cd4942",1359450129,"Implement C++11 [dcl.align]p1 and C11 6.7.5/2 rules for alignas and _Alignas."},

[k]={{p,4435,"/// Perform checking of type validity\n///\n/// C++11 [dcl.align]p1:\n///  An alignment-specifier may be applied to a variable or to a class\n///  data member, but it shall not be applied to a bit-field, a function\n///  parameter, the formal parameter of a catch clause, or a variable\n///  declared with the register storage class specifier. An\n///  alignment-specifier may also be applied to the declaration of a class\n///  or enumeration type.\n/// CWG 2354:\n///  CWG agreed to remove permission for alignas to be applied to\n///  enumerations.\n/// C11 6.7.5/2:\n///  An alignment attribute shall not be specified in a declaration of\n///  a typedef, or a bit-field, or a function, or a parameter, or an\n///  object declared with the register storage-class specifier.\nstatic bool validateAlignasAppliedType(Sema &S, Decl *D, const AlignedAttr &Attr, SourceLocation AttrLoc) {\n  if (DiagKind != -1) {\n    return S.Diag(AttrLoc, diag::err_alignas_attribute_wrong_decl_type) << &Attr << DiagKind;"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of"},

[k]={{q,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  if (OldAlignasAttr && NewAlignasAttr && OldAlign != NewAlign) {\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();"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of"},

[k]={{q,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  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {\n    S.Diag(New->getLocation(), diag::err_alignas_missing_on_definition) << OldAlignasAttr;"},{q,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  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<C11NoReturnAttr>(NewAttribute)) {\n    } else if (isa<UuidAttr>(NewAttribute)) {\n    } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {\n      if (AA->isAlignas()) {\n        S.Diag(Def->getLocation(), diag::err_alignas_missing_on_definition) << AA;"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"848e1f19605a",1359706328,"Implement [dcl.align]p5 and C11 6.7.5/4: alignas cannot underalign."},

[k]={{p,4616,"void Sema::CheckAlignasUnderalignment(Decl *D) {\n  if (Align && DiagTy->isSizelessType()) {\n  } else if (AlignasAttr && Align) {\n    if (NaturalAlign > RequestedAlign)\n      Diag(AlignasAttr->getLocation(), diag::err_alignas_underaligned) << DiagTy << (unsigned)NaturalAlign.getQuantity();"}}

[f]="aligned ... function of type \'A\' is ... available on B...",

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,

[d]={"e5015abf185b",1533337957,"[Preprocessor] Allow libc++ to detect when aligned allocation is unavailable."},

[k]={{x,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    Diag(Loc, diag::err_aligned_allocation_unavailable) << IsDelete << FD.getType().getAsString() << OSName << OSVersion.getAsString() << OSVersion.empty();"}}

[e]=n,

[b]=a,

[h]=o,

[d]={"e2b3744890f6",1336171132,"Move Sema::VerifyIntegerConstantExpression() and"},

[k]={{p,4473,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n  ExprResult ICE = VerifyIntegerConstantExpression(E, &Alignment, diag::err_aligned_attribute_argument_not_int);"}}

[e]=n,

[b]=a,

[h]=o,

[d]={"26a1e0ef760a",1428374229,"[Sema] Don\'t permit dependent alignments on non-dependent typedef-names"},

[k]={{p,4457,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n  if (E->isValueDependent()) {\n    // We can\'t support a dependent alignment on a non-dependent type,\n    // because we have no way to model that a type is \"alignment-dependent\"\n    // but not dependent in any other way.\n    if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {\n      if (!TND->getUnderlyingType()->isDependentType()) {\n        Diag(AttrLoc, diag::err_alignment_dependent_typedef_name) << E->getSourceRange();"},{p,4547,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *TS, bool IsPackExpansion) {\n  if (TS->getType()->isDependentType()) {\n    // We can\'t support a dependent alignment on a non-dependent type,\n    // because we have no way to model that a type is \"type-dependent\"\n    // but not dependent in any other way.\n    if (const auto *TND = dyn_cast<TypedefNameDecl>(D)) {\n      if (!TND->getUnderlyingType()->isDependentType()) {\n        Diag(AttrLoc, diag::err_alignment_dependent_typedef_name) << TS->getTypeLoc().getSourceRange();"}}

[e]=n,

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

[i]=m,

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

[d]={"bcc06085a894",1410130694,"Add __builtin_assume and __builtin_assume_aligned using @llvm.assume."},

[k]={{s,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  // 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    if (!AlignValue.isPowerOf2()) {\n      S.Diag(AlignOp->getExprLoc(), diag::err_alignment_not_power_of_two);"},{s,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  // We can\'t check the value of a dependent argument.\n  if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n    if (!Result.isPowerOf2())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two) << Arg->getSourceRange();"},{s,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  // We can\'t check the value of a dependent argument.\n  if (!SecondArg->isValueDependent()) {\n    if (!Result.isPowerOf2())\n      return Diag(TheCall->getBeginLoc(), diag::err_alignment_not_power_of_two) << SecondArg->getSourceRange();"},{p,1711,"void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE) {\n  if (!E->isValueDependent()) {\n    if (!I->isPowerOf2()) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"},{p,4336,"void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {\n  if (!E->isValueDependent()) {\n    if (!Alignment.isPowerOf2()) {\n      Diag(AttrLoc, diag::err_alignment_not_power_of_two) << E->getSourceRange();"},{p,4494,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\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();"}}

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

[c]=l,

[e]=n,

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

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

[b]=a,

[h]=o,