Module:ClangDiags/DiagsLongData15
Jump to navigation
Jump to search
Documentation for this module may be created at Module:ClangDiags/DiagsLongData15/doc
local a="commit";
local b="message_hist";
local c="hierarchical_hist";
local d="regex1";
local e="regex2";
local f="regex3";
local g="id_hist";
local h="category_hist";
local i="source";
local j="groups";
local k="maingroup";
local l="tests2";
local m="(?:warning|error|fatal error)\\: ";
local n="Semantic Issue";
local o="clang/lib/Sema/SemaDeclAttr.cpp";
local p="12.0";
local q="ignored-attributes";
local r="";
local s="10.0";
local t="11.0";
local u="clang/lib/Sema/SemaChecking.cpp";
local v="16.0";
local w="13.0";
local x="attributes";
local y=" \\[(?:\\-Werror,)?\\-Wignored\\-attributes[^\\]]*\\]";
local z="14.0";
local A="Lexical or Preprocessor Issue";
local B="9.0";
local C="clang/lib/Sema/SemaDeclCXX.cpp";
local D="15.0";
local E="5.0";
local F="7.0";
local G="clang/lib/Sema/SemaExpr.cpp";
local H="clang/lib/Sema/SemaDecl.cpp";
local I="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 J="The basic representation of diagnostics information in tablegen format, plus (uncommented and incomp...";
local K="b1c4d5507fad";
local L="swift-name-attribute";
local M="clang/lib/Sema/AnalysisBasedWarnings.cpp";
local N="6.0";
local O="None";
local P="CL4";
local Q="pre-c2x-compat";
local R="note\\: ";
local S="clang/lib/Lex/PPDirectives.cpp";
local T="all";
local U="remark\\: ";
local V="8.0";
local W="clang/lib/Sema/SemaDeclObjC.cpp";
local X="clang/lib/Sema/SemaStmt.cpp";
local Y="[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 Z="[clang] Implement objc_non_runtime_protocol to remove protocol metadata";
local ab="14f6bfcb52e7";
local bb="clang/lib/Lex/Lexer.cpp";
local cb="most";
local db="Parse Issue";
local eb="deprecated";
local fb=" \\[(?:\\-Werror,)?\\-Wswift\\-name\\-attribute[^\\]]*\\]";
local gb="availability";
local hb="61d065e21ff3";
local ib="Let clang atomic builtins fetch add/sub support floating point types";
local jb="(?: \\[(?:\\-Werror)?[^\\]]*\\])?";
local kb="Let clang atomic builtins fetch add/sub support floating point types\n\nRecently atomicrmw started to support fadd/fsub:\n\nhttps://reviews.llvm.org/D53965\n\nHowever clang atomic builtins fetch add/sub still does not support\nemitting atomicrmw fadd/fsub.\n\nThis patch adds that.\n\nReviewed by: John McCall, Artem Belevich, Matt Arsenault, JF Bastien,\nJames Y Knight, Louis Dionne, Olivier Giroux\n\nDifferential Revision: https://reviews.llvm.org/D71726";
local lb="clang/lib/Sema/SemaType.cpp";
local mb="clang/lib/Sema/SemaCast.cpp";
local nb="pre-c2x-compat-pedantic";
local ob=" \\[(?:\\-Werror,)?\\-Wpre\\-c2x\\-compat[^\\]]*\\]";
local pb="clang/lib/Sema/SemaObjCProperty.cpp";
local qb="comparison of";
local rb="Implement P2361 Unevaluated string literals";
local sb="95f50964fbf5";
local tb="overriding-method-mismatch";
local ub="conditional expression between";
local vb="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 wb="bitwise operation between";
local xb="arithmetic between";
local yb="compound assignment of";
local zb="fe17b30a7957";
local Ab="called-once-parameter";
local Bb="conversion";
local Cb="non-gcc";
local Db="[attributes][analyzer] Add annotations for handles.";
local Eb="[attributes][analyzer] Add annotations for handles.\n\nThese annotations will be used in an upcomming static analyzer check\nthat finds handle leaks, use after releases, and double releases.\n\nDifferential Revision: https://reviews.llvm.org/D70469";
local Fb="clang/test/SemaObjC/attr-swift_name.m";
local Gb="Deprecations";
local Hb="5a8987ca5113";
local Ib="Update tablegen diagnostic files to be in sync with the def files.";
local Jb="trigraphs";
local Kb="functions";
local Lb="Update tablegen diagnostic files to be in sync with the def files.\n\nllvm-svn: 67004";
local Mb="module-build";
local Nb=" (B and C)";
local Ob=" different enumeration types";
local Pb="clang/test/SemaSYCL/zero-length-arrays.cpp:31:24: note: within field of type \'InnerTemplated<0U>[1]\' declared here";
local Qb="(?:error|fatal error)\\: ";
local Rb="clang/lib/Sema/SemaInit.cpp";
local Sb="A";
local Tb="clang/lib/Parse/ParseDecl.cpp";
local Ub="Reland [clang] Check unsupported types in expressions\n\nThis was committed as ec6c847179fd, but then reverted after a failure\nin: https://lab.llvm.org/buildbot/#/builders/84/builds/13983\n\nI was not able to reproduce the problem, but I added an extra check\nfor a NULL QualType just in case.\n\nOriginal comit message:\n\nThe patch adds missing diagnostics for cases like:\n\n float F3 = ((__float128)F1 * (__float128)F2) / 2.0f;\n\nSema::checkDeviceDecl (renamed to checkTypeSupport) is changed to work\nwith a type without the corresponding ValueDecl. It is also refactored\nso that host diagnostics for unsupported types can be added here as\nwell.\n\nDifferential Revision: https://reviews.llvm.org/D109315";
local Vb="Reland [clang] Check unsupported types in expressions";
local Wb="3dbcea8b957a";
local Xb="tautological-compare";
local Yb="pass-analysis";
local Zb="thread-safety-analysis";
local ac="Value Conversion Issue";
local bc="completion-handler";
local cc="using the result of an assignment as a condition without parentheses";
local dc="c99-compat";
local ec="clang/lib/Sema/SemaExprObjC.cpp";
local fc=" \\[(?:\\-Werror,)?\\-Wavailability[^\\]]*\\]";
local gc="array-bounds";
local hc="clang/test/SemaObjC/warn-called-once.m";
local ic="arc-unsafe-retained-assign";
local jc="enum-conversion";
local kc="gcc-compat";
local lc="conflicting variadic declaration of method and its implementation";
local mc="clang/lib/Sema/SemaTemplate.cpp";
local nc="Backend Issue";
local oc="ARC Semantic Issue";
local pc="class-conversion";
local qc="functions and methods";
local rc="non-K&R-style functions";
local sc="function";
local tc=" ";
local uc="variables, functions and classes";
local vc="types and namespaces";
local wc="variables, data members and tag types";
local xc="variables and fields";
local yc="clang/test/CXX/expr/expr.arith.conv/p2.cpp";
local zc="(?:error|warning|fatal error)\\: ";
local Ac="(.*?)";
local Bc="variables";
local Cc="%0";
local Dc="clang/lib/Lex/LiteralSupport.cpp";
local Ec="unions";
local Fc="variables and functions";
local Gc="functions, methods and blocks";
local Hc="functions, methods, and parameters";
local Ic="kernel functions";
local Jc="clang/lib/Lex/Pragma.cpp";
local Kc="variable";
local Lc="3c12dd7675cd";
local Mc="clang/lib/CodeGen/CodeGenAction.cpp";
local Nc="extra";
local Oc=" \\[(?:\\-Werror,)?\\-Woverriding\\-method\\-mismatch[^\\]]*\\]";
local Pc="objective-c: Using existing infrastructure for finding ";
local Qc="objective-c: Using existing infrastructure for finding \noverridden methods to diagnose their type mismatch.\nThis is a general solution for previous fixes\nfor // rdar://6191214 and // rdar://9352731\nand removes lots of duplicate code.\n\nllvm-svn: 137222";
local Rc="arc";
local Sc="7.1";
local Tc="clang/lib/Frontend/CompilerInstance.cpp";
return {
["note_using"]={
[g]="note_using",
[b]="using",
[c]="using",
[d]=R,
[e]="using",
[f]=r,
[h]=O,
[a]={"e29c5cd2398c",1260474663,"Improve the diagnostic when a new declaration conflicts with a using shadow","Improve the diagnostic when a new declaration conflicts with a using shadow\ndeclaration. Rename note_using_decl to note_using, which is possibly less confusing.\nAdd a test for non-class-scope using decl collisions and be sure to note the case\nwe can\'t diagnose yet.\n\nllvm-svn: 91057"},
[i]={{W,3642,"void Sema::DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass) {\n // ...\n if (issueDiagnostic) {\n // ...\n Diag(Methods[0]->getBeginLoc(), issueError ? diag::note_possibility : diag::note_using) << Methods[0]->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/selector-overload.m"]={"clang/test/SemaObjC/selector-overload.m:15:1: note: using"}
}
},
["note_using_decl"]={
[g]="note_using_decl",
[b]="%select{|previous }0using declaration",
[c]={{nil,nil,{{r,"previous "},"using declaration"}}},
[d]=R,
[e]="(?:|previous )using declaration",
[f]=r,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{H,3556,"/// Check whether a redeclaration of an entity introduced by a\n/// using-declaration is valid, given that we know it\'s not an overload\n/// (nor a hidden tag declaration).\ntemplate <typename ExpectedDecl> static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New) {\n // ...\n if (!Old) {\n // ...\n S.Diag(OldS->getIntroducer()->getLocation(), diag::note_using_decl) << 0;"},{H,3641,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'. Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n // ...\n if (!Old) {\n if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {\n if (New->getFriendObjectKind()) {\n // ...\n Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;"},{H,17217,"/// This is invoked when we see \'struct foo\' or \'struct {\'. In the\n/// former case, Name will be non-null. In the later case, Name will be null.\n/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a\n/// reference/declaration/definition of a tag.\n///\n/// \\param IsTypeSpecifier \\c true if this is a type-specifier (or\n/// trailing-type-specifier) other than one in an alias-declaration.\n///\n/// \\param SkipBody If non-null, will be set to indicate if the caller should\n/// skip the definition of this tag and treat it as if it were a declaration.\nDeclResult Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attrs, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody) {\n // ...\n if (!Previous.empty()) {\n // ...\n // If this is a redeclaration of a using shadow declaration, it must\n // declare a tag in the same context. In MSVC mode, we allow a\n // redefinition if either context is within the other.\n if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {\n // ...\n if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend && isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) && !(OldTag && isAcceptableTagRedeclContext(*this, OldTag->getDeclContext(), SearchDC))) {\n // ...\n Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;"},{C,12989,"/// Checks that the given using declaration is not an invalid\n/// redeclaration. Note that this is checking only for the using decl\n/// itself, not for any ill-formedness among the UsingShadowDecls.\nbool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Prev) {\n // ...\n for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {\n // ...\n Diag(D->getLocation(), diag::note_using_decl) << 1;"},{mc,1981,"DeclResult Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {\n // ...\n if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {\n if (SS.isEmpty() && !(PrevClassTemplate && PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(SemanticContext->getRedeclContext()))) {\n // ...\n Diag(Shadow->getIntroducer()->getLocation(), diag::note_using_decl) << 0;"}},
[l]={
["clang/test/SemaCXX/lookup-member.cpp"]={"clang/test/SemaCXX/lookup-member.cpp:7:10: note: using declaration"}
}
},
["note_using_decl_class_member_workaround"]={
[g]="note_using_decl_class_member_workaround",
[b]="use %select{an alias declaration|a typedef declaration|a reference|a const variable|a constexpr variable}0 instead",
[c]={{nil,nil,{"use ",{"an alias declaration","a typedef declaration","a reference","a const variable","a constexpr variable"}," instead"}}},
[d]=R,
[e]="use (?:an alias declaration|a typedef declaration|a reference|a const variable|a constexpr variable) instead",
[f]=r,
[h]=n,
[a]={"7ad0b8839652",1396475075,"If a using-declaration names a class member, but appears outside a class, try","If a using-declaration names a class member, but appears outside a class, try\nto suggest a different syntax to get the same effect.\n\nllvm-svn: 205467"},
[i]={{C,13075,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope. If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n // ...\n if (!CurContext->isRecord()) {\n // ...\n if (RD && !RequireCompleteDeclContext(const_cast<CXXScopeSpec &>(SS), RD)) {\n // ...\n if (!R) {\n // ...\n } else if (R->getAsSingle<TypeDecl>()) {\n if (getLangOpts().CPlusPlus11) {\n // ...\n Diag(SS.getBeginLoc(), diag::note_using_decl_class_member_workaround) << 0 // alias declaration"},{C,13083,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope. If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n // ...\n if (!CurContext->isRecord()) {\n // ...\n if (RD && !RequireCompleteDeclContext(const_cast<CXXScopeSpec &>(SS), RD)) {\n // ...\n if (!R) {\n // ...\n } else if (R->getAsSingle<TypeDecl>()) {\n if (getLangOpts().CPlusPlus11) {\n // ...\n } else {\n // ...\n Diag(InsertLoc, diag::note_using_decl_class_member_workaround) << 1 // typedef declaration"},{C,13099,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope. If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n // ...\n if (!CurContext->isRecord()) {\n // ...\n if (RD && !RequireCompleteDeclContext(const_cast<CXXScopeSpec &>(SS), RD)) {\n // ...\n if (!R) {\n // ...\n } else if (R->getAsSingle<TypeDecl>()) {\n // ...\n } else if (R->getAsSingle<VarDecl>()) {\n // ...\n Diag(UsingLoc, diag::note_using_decl_class_member_workaround) << 2 // reference declaration"},{C,13114,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope. If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n // ...\n if (!CurContext->isRecord()) {\n // ...\n if (RD && !RequireCompleteDeclContext(const_cast<CXXScopeSpec &>(SS), RD)) {\n // ...\n if (!R) {\n // ...\n } else if (R->getAsSingle<TypeDecl>()) {\n // ...\n } else if (R->getAsSingle<VarDecl>()) {\n // ...\n } else if (R->getAsSingle<EnumConstantDecl>()) {\n // ...\n Diag(UsingLoc, diag::note_using_decl_class_member_workaround) << (getLangOpts().CPlusPlus11 ? 4 : 3) // const[expr] variable"}},
[l]={
["clang/test/SemaTemplate/cxx1z-using-declaration.cpp"]={"clang/test/SemaTemplate/cxx1z-using-declaration.cpp:130:3: note: use a reference instead","clang/test/SemaTemplate/cxx1z-using-declaration.cpp:130:9: note: use an alias declaration instead"}
}
},
["note_using_decl_conflict"]={
[g]="note_using_decl_conflict",
[b]="conflicting declaration",
[c]="conflicting declaration",
[d]=R,
[e]="conflicting declaration",
[f]=r,
[h]=n,
[a]={"84d8767c1582",1260438112,"Implement redeclaration checking and hiding semantics for using declarations. There","Implement redeclaration checking and hiding semantics for using declarations. There\nare a couple of O(n^2) operations in this, some analogous to the usual O(n^2)\nredeclaration problem and some not. In particular, retroactively removing\nshadow declarations when they\'re hidden by later decls is pretty unfortunate.\nI\'m not yet convinced it\'s worse than the alternative, though.\n\nllvm-svn: 91045"},
[i]={{C,12279,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n // Always emit a diagnostic for a mismatch between an unresolved\n // using_if_exists and a resolved using declaration in either direction.\n if (isa<UnresolvedUsingIfExistsDecl>(Target) != (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {\n // ...\n Diag((NonTag ? NonTag : Tag)->getLocation(), diag::note_using_decl_conflict);"},{C,12309,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n if (FunctionDecl *FD = Target->getAsFunction()) {\n // ...\n Diag(OldDecl->getLocation(), diag::note_using_decl_conflict);"},{C,12322,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n if (isa<TagDecl>(Target)) {\n // ...\n Diag(Tag->getLocation(), diag::note_using_decl_conflict);"},{C,12332,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n Diag(NonTag->getLocation(), diag::note_using_decl_conflict);"}},
[l]={
["clang/test/Parser/cxx1z-using-declaration.cpp"]={"clang/test/Parser/cxx1z-using-declaration.cpp:13:18: note: conflicting declaration","clang/test/Parser/cxx1z-using-declaration.cpp:13:18: note: conflicting declaration"}
}
},
["note_using_decl_target"]={
[g]="note_using_decl_target",
[b]="target of using declaration",
[c]="target of using declaration",
[d]=R,
[e]="target of using declaration",
[f]=r,
[h]=n,
[a]={"e61f2ba7e44a",1258511779,"Incremental progress on using declarations. Split UnresolvedUsingDecl into","Incremental progress on using declarations. Split UnresolvedUsingDecl into\ntwo classes, one for typenames and one for values; this seems to have some\nsupport from Doug if not necessarily from the extremely-vague-on-this-point\nstandard. Track the location of the \'typename\' keyword in a using-typename\ndecl. Make a new lookup result for unresolved values and deal with it in\nmost places.\n\nllvm-svn: 89184"},
[i]={{H,3555,"/// Check whether a redeclaration of an entity introduced by a\n/// using-declaration is valid, given that we know it\'s not an overload\n/// (nor a hidden tag declaration).\ntemplate <typename ExpectedDecl> static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New) {\n // ...\n if (!Old) {\n // ...\n S.Diag(OldS->getTargetDecl()->getLocation(), diag::note_using_decl_target);"},{H,3640,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'. Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n // ...\n if (!Old) {\n if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {\n if (New->getFriendObjectKind()) {\n // ...\n Diag(Shadow->getTargetDecl()->getLocation(), diag::note_using_decl_target);"},{H,17216,"/// This is invoked when we see \'struct foo\' or \'struct {\'. In the\n/// former case, Name will be non-null. In the later case, Name will be null.\n/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a\n/// reference/declaration/definition of a tag.\n///\n/// \\param IsTypeSpecifier \\c true if this is a type-specifier (or\n/// trailing-type-specifier) other than one in an alias-declaration.\n///\n/// \\param SkipBody If non-null, will be set to indicate if the caller should\n/// skip the definition of this tag and treat it as if it were a declaration.\nDeclResult Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attrs, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody) {\n // ...\n if (!Previous.empty()) {\n // ...\n // If this is a redeclaration of a using shadow declaration, it must\n // declare a tag in the same context. In MSVC mode, we allow a\n // redefinition if either context is within the other.\n if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {\n // ...\n if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend && isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) && !(OldTag && isAcceptableTagRedeclContext(*this, OldTag->getDeclContext(), SearchDC))) {\n // ...\n Diag(Shadow->getTargetDecl()->getLocation(), diag::note_using_decl_target);"},{C,12203,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // Diagnose finding a decl which is not from a base class of the\n // current class. We do this now because there are cases where this\n // function will silently decide not to build a shadow decl, which\n // will pre-empt further diagnostics.\n //\n // We don\'t need to do this in C++11 because we do the check once on\n // the qualifier.\n //\n // FIXME: diagnose the following if we care enough:\n // struct A { int foo; };\n // struct B : A { using A::foo; };\n // template <class T> struct C : A {};\n // template <class T> struct D : C<T> { using B::foo; } // <---\n // This is invalid (during instantiation) in C++03 because B::foo\n // resolves to the using decl in B, which is not a base class of D<T>.\n // We can\'t diagnose it immediately because C<T> is an unknown\n // specialization. The UsingShadowDecl in D<T> then points directly\n // to A::foo, which will look well-formed when we instantiate.\n // The right solution is to not collapse the shadow-decl chain.\n if (!getLangOpts().CPlusPlus11 && CurContext->isRecord())\n if (auto *Using = dyn_cast<UsingDecl>(BUD)) {\n // ...\n if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {\n if (OrigDC == CurContext) {\n // ...\n Diag(Orig->getLocation(), diag::note_using_decl_target);"},{C,12212,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // Diagnose finding a decl which is not from a base class of the\n // current class. We do this now because there are cases where this\n // function will silently decide not to build a shadow decl, which\n // will pre-empt further diagnostics.\n //\n // We don\'t need to do this in C++11 because we do the check once on\n // the qualifier.\n //\n // FIXME: diagnose the following if we care enough:\n // struct A { int foo; };\n // struct B : A { using A::foo; };\n // template <class T> struct C : A {};\n // template <class T> struct D : C<T> { using B::foo; } // <---\n // This is invalid (during instantiation) in C++03 because B::foo\n // resolves to the using decl in B, which is not a base class of D<T>.\n // We can\'t diagnose it immediately because C<T> is an unknown\n // specialization. The UsingShadowDecl in D<T> then points directly\n // to A::foo, which will look well-formed when we instantiate.\n // The right solution is to not collapse the shadow-decl chain.\n if (!getLangOpts().CPlusPlus11 && CurContext->isRecord())\n if (auto *Using = dyn_cast<UsingDecl>(BUD)) {\n // ...\n if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {\n // ...\n Diag(Orig->getLocation(), diag::note_using_decl_target);"},{C,12277,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n // Always emit a diagnostic for a mismatch between an unresolved\n // using_if_exists and a resolved using declaration in either direction.\n if (isa<UnresolvedUsingIfExistsDecl>(Target) != (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {\n // ...\n Diag(Target->getLocation(), diag::note_using_decl_target);"},{C,12308,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n if (FunctionDecl *FD = Target->getAsFunction()) {\n // ...\n Diag(Target->getLocation(), diag::note_using_decl_target);"},{C,12321,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n if (isa<TagDecl>(Target)) {\n // ...\n Diag(Target->getLocation(), diag::note_using_decl_target);"},{C,12331,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n // ...\n Diag(Target->getLocation(), diag::note_using_decl_target);"},{C,12778,"/// Builds a using declaration.\n///\n/// \\param IsInstantiation - Whether this call arises from an\n/// instantiation of an unresolved using declaration. We treat\n/// the lookup differently for these declarations.\nNamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists) {\n // ...\n if (HasTypenameKeyword) {\n // If we asked for a typename and got a non-type decl, error out.\n if (!R.getAsSingle<TypeDecl>() && !R.getAsSingle<UnresolvedUsingIfExistsDecl>()) {\n // ...\n for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)\n Diag((*I)->getUnderlyingDecl()->getLocation(), diag::note_using_decl_target);"},{C,12787,"/// Builds a using declaration.\n///\n/// \\param IsInstantiation - Whether this call arises from an\n/// instantiation of an unresolved using declaration. We treat\n/// the lookup differently for these declarations.\nNamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists) {\n // ...\n if (HasTypenameKeyword) {\n // ...\n } else {\n // If we asked for a non-typename and we got a type, error out,\n // but only if this is an instantiation of an unresolved using\n // decl. Otherwise just silently find the type name.\n if (IsInstantiation && R.getAsSingle<TypeDecl>()) {\n // ...\n Diag(R.getFoundDecl()->getLocation(), diag::note_using_decl_target);"},{"clang/lib/Sema/SemaModule.cpp",858,"/// Check that it\'s valid to export \\p D.\nstatic bool checkExportedDecl(Sema &S, Decl *D, SourceLocation BlockStart) {\n // ...\n // C++2a [module.interface]p5:\n // all entities to which all of the using-declarators ultimately refer\n // shall have been introduced with a name having external linkage\n if (auto *USD = dyn_cast<UsingShadowDecl>(D)) {\n // ...\n if (Lk == InternalLinkage || Lk == ModuleLinkage) {\n // ...\n S.Diag(Target->getLocation(), diag::note_using_decl_target);"},{mc,1980,"DeclResult Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {\n // ...\n if (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {\n if (SS.isEmpty() && !(PrevClassTemplate && PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(SemanticContext->getRedeclContext()))) {\n // ...\n Diag(Shadow->getTargetDecl()->getLocation(), diag::note_using_decl_target);"}},
[l]={
["clang/test/SemaCXX/lookup-member.cpp"]={"clang/test/SemaCXX/lookup-member.cpp:4:9: note: target of using declaration"}
}
},
["note_using_enum_decl"]={
[g]={{nil,w,"note_using_enum_decl"}},
[b]={{nil,w,"%select{|previous }0using-enum declaration"}},
[c]={{nil,w,{{r,"previous "},"using-enum declaration"}}},
[d]=R,
[e]="(?:|previous )using\\-enum declaration",
[f]=r,
[h]={{nil,w,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{C,12842,"NamedDecl *Sema::BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation NameLoc, TypeSourceInfo *EnumType, EnumDecl *ED) {\n // ...\n if (CurContext->getRedeclContext()->isRecord()) {\n // ...\n for (NamedDecl *D : Previous)\n if (UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D))\n if (UED->getEnumDecl() == ED) {\n // ...\n Diag(D->getLocation(), diag::note_using_enum_decl) << 1;"}},
[l]={
["clang/test/SemaCXX/cxx20-using-enum.cpp"]={"clang/test/SemaCXX/cxx20-using-enum.cpp:229:14: note: previous using-enum declaration","clang/test/SemaCXX/cxx20-using-enum.cpp:235:14: note: previous using-enum declaration"}
}
},
["note_using_value_decl_missing_typename"]={
[g]="note_using_value_decl_missing_typename",
[b]="add \'typename\' to treat this using declaration as a type",
[c]="add \'typename\' to treat this using declaration as a type",
[d]=R,
[e]="add \'typename\' to treat this using declaration as a type",
[f]=r,
[h]=n,
[a]={"aed2efbbb54f",1291853187,"A typename specifier can end up referring to a unresolved using","A typename specifier can end up referring to a unresolved using\ndeclaration that is a value in ill-formed code. Instead of crashing,\ntreat this as a dependent typename specifier and suggest that the\nusing add \"typename\" into the using declaration. Fixes <rdar://problem/8740998>.\n\nllvm-svn: 121322"},
[i]={{mc,11073,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n // ...\n case LookupResult::FoundUnresolvedValue: {\n // ...\n if (UnresolvedUsingValueDecl *Using = dyn_cast<UnresolvedUsingValueDecl>(Result.getRepresentativeDecl())) {\n // ...\n Diag(Loc, diag::note_using_value_decl_missing_typename) << FixItHint::CreateInsertion(Loc, \"typename \");"}},
[l]={
["clang/test/SemaTemplate/typename-specifier-4.cpp"]={"clang/test/SemaTemplate/typename-specifier-4.cpp:146:11: note: add \'typename\' to treat this using declaration as a type"}
}
},
["note_valid_options"]={
[g]={{nil,F,"note_valid_options"}},
[b]={{nil,F,"valid target CPU values are: %0"}},
[c]={{nil,F,"valid target CPU values are: A"}},
[d]=R,
[e]="valid target CPU values are\\: (.*?)",
[f]=r,
[h]={{nil,F,O}},
[a]={"3ec1743d0d77",1518131655,"Make march/target-cpu print a note with the list of valid values for ARM","Make march/target-cpu print a note with the list of valid values for ARM\n\nWhen rejecting a march= or target-cpu command line parameter,\nthe message is quite lacking. This patch adds a note that prints\nall possible values for the current target, if the target supports it.\n\nThis adds support for the ARM/AArch64 targets (more to come!). \n\nDifferential Revision: https://reviews.llvm.org/D42978 \n\nllvm-svn: 324673"},
[i]={{"clang/lib/Basic/Targets.cpp",792,"/// CreateTargetInfo - Return the target info object for the specified target\n/// options.\nTargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr<TargetOptions> &Opts) {\n // ...\n // Set the target CPU if specified.\n if (!Opts->CPU.empty() && !Target->setCPU(Opts->CPU)) {\n // ...\n if (!ValidList.empty())\n Diags.Report(diag::note_valid_options) << llvm::join(ValidList, \", \");"},{"clang/lib/Basic/Targets.cpp",803,"/// CreateTargetInfo - Return the target info object for the specified target\n/// options.\nTargetInfo *TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags, const std::shared_ptr<TargetOptions> &Opts) {\n // ...\n // Check the TuneCPU name if specified.\n if (!Opts->TuneCPU.empty() && !Target->isValidTuneCPUName(Opts->TuneCPU)) {\n // ...\n if (!ValidList.empty())\n Diags.Report(diag::note_valid_options) << llvm::join(ValidList, \", \");"}},
[l]={
["clang/test/Preprocessor/predefined-arch-macros.c"]={"note: valid target CPU values are: nocona, core2, penryn, bonnell, atom, silvermont, slm, goldmont, goldmont-plus, tremont, nehalem, corei7, westmere, sandybridge, corei7-avx, ivybridge, core-avx-i, haswell, core-avx2, broadwell, skylake, skylake-avx512, skx, cascadelake, cooperlake, cannonlake, icelake-client, rocketlake, icelake-server, tigerlake, sapphirerapids, alderlake, raptorlake, meteorlake, sierraforest, grandridge, graniterapids, graniterapids-d, emeraldrapids, knl, knm, k8, athlon64, athlon-fx, opteron, k8-sse3, athlon64-sse3, opteron-sse3, amdfam10, barcelona, btver1, btver2, bdver1, bdver2, bdver3, bdver4, znver1, znver2, znver3, znver4, x86-64, x86-64-v2, x86-64-v3, x86-64-v4"}
}
},
["note_value_initialization_here"]={
[g]="note_value_initialization_here",
[b]="in value-initialization of type %0 here",
[c]="in value-initialization of type A here",
[d]=R,
[e]="in value\\-initialization of type (.*?) here",
[f]=r,
[h]=n,
[a]={"593f993a6855",1354932077,"Implement C++03 [dcl.init]p5\'s checking for value-initialization of references","Implement C++03 [dcl.init]p5\'s checking for value-initialization of references\nproperly, rather than faking it up by pretending that a reference member makes\nthe default constructor non-trivial. That leads to rejects-valids when putting\nsuch types inside unions.\n\nllvm-svn: 169662"},
[i]={{Rb,9445,"/// Somewhere within T there is an uninitialized reference subobject.\n/// Dig it out and diagnose it.\nstatic bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T) {\n // ...\n for (const auto *FI : RD->fields()) {\n // ...\n if (DiagnoseUninitializedReference(S, FI->getLocation(), FI->getType())) {\n S.Diag(Loc, diag::note_value_initialization_here) << RD;"},{Rb,9452,"/// Somewhere within T there is an uninitialized reference subobject.\n/// Dig it out and diagnose it.\nstatic bool DiagnoseUninitializedReference(Sema &S, SourceLocation Loc, QualType T) {\n // ...\n for (const auto &BI : RD->bases()) {\n if (DiagnoseUninitializedReference(S, BI.getBeginLoc(), BI.getType())) {\n S.Diag(Loc, diag::note_value_initialization_here) << RD;"}},
[l]={
["clang/test/CXX/dcl.decl/dcl.init/p5.cpp"]={"clang/test/CXX/dcl.decl/dcl.init/p5.cpp:20:10: note: in value-initialization of type \'S\' here","clang/test/CXX/dcl.decl/dcl.init/p5.cpp:24:5: note: in value-initialization of type \'S\' here","clang/test/CXX/dcl.decl/dcl.init/p5.cpp:26:7: note: in value-initialization of type \'T\' here","clang/test/CXX/dcl.decl/dcl.init/p5.cpp:24:5: note: in value-initialization of type \'S\' here","clang/test/CXX/dcl.decl/dcl.init/p5.cpp:29:5: note: in value-initialization of type \'T\' here","clang/test/CXX/dcl.decl/dcl.init/p5.cpp:31:7: note: in value-initialization of type \'U\' here"}
}
},
["note_var_declared_here"]={
[g]="note_var_declared_here",
[b]="variable %0 is declared here",
[c]="variable A is declared here",
[d]=R,
[e]="variable (.*?) is declared here",
[f]=r,
[h]=n,
[a]={"f463a8a424e7",1461890263,"Avoid -Wshadow warnings about constructor parameters named after fields","Avoid -Wshadow warnings about constructor parameters named after fields\n\nUsually these parameters are used solely to initialize the field in the\ninitializer list, and there is no real shadowing confusion.\n\nThere is a new warning under -Wshadow called\n-Wshadow-field-in-constructor-modified. It attempts to find\nmodifications of such constructor parameters that probably intended to\nmodify the field.\n\nIt has some false negatives, though, so there is another warning group,\n-Wshadow-field-in-constructor, which always warns on this special case.\nFor users who just want the old behavior and don\'t care about these fine\ngrained groups, we have a new warning group called -Wshadow-all that\nactivates everything.\n\nFixes PR16088.\n\nReviewers: rsmith\n\nSubscribers: cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D18271\n\nllvm-svn: 267957"},
[i]={{M,1052,"/// DiagnoseUninitializedUse -- Helper function for diagnosing uses of an\n/// uninitialized variable. This manages the different forms of diagnostic\n/// emitted for particular types of uses. Returns true if the use was diagnosed\n/// as a warning. If a particular use is one we omit warnings for, returns\n/// false.\nstatic bool DiagnoseUninitializedUse(Sema &S, const VarDecl *VD, const UninitUse &Use, bool alwaysReportSelfInit = false) {\n // ...\n // Report where the variable was declared when the use wasn\'t within\n // the initializer of that declaration & we didn\'t already suggest\n // an initialization fixit.\n if (!SuggestInitializationFixit(S, VD))\n S.Diag(VD->getBeginLoc(), diag::note_var_declared_here) << VD->getDeclName();"},{H,8386,"/// Check if \'E\', which is an expression that is about to be modified, refers\n/// to a constructor parameter that shadows a field.\nvoid Sema::CheckShadowingDeclModification(Expr *E, SourceLocation Loc) {\n // ...\n Diag(D->getLocation(), diag::note_var_declared_here) << D;"},{C,11599,"struct InvalidSTLDiagnoser {\n // ...\n QualType operator()(UnsupportedSTLSelect Sel = USS_Other, StringRef Name = \"\", const VarDecl *VD = nullptr) {\n // ...\n if (Sel == USS_InvalidMember) {\n S.Diag(VD->getLocation(), diag::note_var_declared_here) << VD << VD->getSourceRange();"}},
[l]={
["clang/test/SemaCXX/warn-shadow.cpp"]={"clang/test/SemaCXX/warn-shadow.cpp:51:9: note: variable \'f1\' is declared here","clang/test/SemaCXX/warn-shadow.cpp:51:17: note: variable \'f2\' is declared here","clang/test/SemaCXX/warn-shadow.cpp:51:25: note: variable \'f3\' is declared here","clang/test/SemaCXX/warn-shadow.cpp:51:33: note: variable \'f4\' is declared here"}
}
},
["note_var_explicitly_captured_here"]={
[g]="note_var_explicitly_captured_here",
[b]="variable %0 is%select{| explicitly}1 captured here",
[c]={{nil,nil,{"variable A is",{r," explicitly"}," captured here"}}},
[d]=R,
[e]="variable (.*?) is(?:| explicitly) captured here",
[f]=r,
[h]="Lambda Issue",
[a]={"175388c00d0a",1478687937,"[Sema] Avoid -Wshadow warnings for shadowed variables that aren\'t captured","[Sema] Avoid -Wshadow warnings for shadowed variables that aren\'t captured\nby lambdas with an explicit capture list\n\nThis commit avoids the -Wshadow warning for variables which shadow variables\nthat aren\'t captured by lambdas with an explicit capture list. It provides an\nadditional note that points to location of the explicit capture.\n\nThe old behaviour is preserved with -Wshadow-all or -Wshadow-uncaptured-local.\n\nrdar://17135966\n\nDifferential Revision: https://reviews.llvm.org/D26278\n\nllvm-svn: 286354"},
[i]={{H,8332,"/// Diagnose variable or built-in function shadowing. Implements\n/// -Wshadow.\n///\n/// This method is called whenever a VarDecl is added to a \"useful\"\n/// scope.\n///\n/// \\param ShadowedDecl the declaration that is shadowed by the given variable\n/// \\param R the lookup of the name\n///\nvoid Sema::CheckShadow(NamedDecl *D, NamedDecl *ShadowedDecl, const LookupResult &R) {\n // ...\n if (!CaptureLoc.isInvalid())\n Diag(CaptureLoc, diag::note_var_explicitly_captured_here) << Name << /*explicitly*/ 1;"},{H,8351,"/// Diagnose shadowing for variables shadowed in the lambda record \\p LambdaRD\n/// when these variables are captured by the lambda.\nvoid Sema::DiagnoseShadowingLambdaDecls(const LambdaScopeInfo *LSI) {\n for (const auto &Shadow : LSI->ShadowingDecls) {\n // ...\n if (!CaptureLoc.isInvalid())\n Diag(CaptureLoc, diag::note_var_explicitly_captured_here) << Shadow.VD->getDeclName() << /*explicitly*/ 0;"},{"clang/lib/Sema/SemaLambda.cpp",1352,"void Sema::ActOnStartOfLambdaDefinition(LambdaIntroducer &Intro, Declarator &ParamInfo, const DeclSpec &DS) {\n // ...\n auto CheckRedefinition = [&](ParmVarDecl *Param) {\n for (const auto &Capture : Intro.Captures) {\n if (Capture.Id == Param->getIdentifier()) {\n // ...\n Diag(Capture.Loc, diag::note_var_explicitly_captured_here) << Capture.Id << true;"},{"clang/lib/Sema/SemaOpenMP.cpp",23126,"static void checkDeclInTargetContext(SourceLocation SL, SourceRange SR, Sema &SemaRef, Decl *D) {\n // ...\n if (SemaRef.LangOpts.OpenMP >= 50 && (SemaRef.getCurLambda(/*IgnoreNonLambdaCapturingScope=*/true) || SemaRef.getCurBlock() || SemaRef.getCurCapturedRegion()) && VD->hasGlobalStorage()) {\n if (!MapTy || (*MapTy != OMPDeclareTargetDeclAttr::MT_To && *MapTy != OMPDeclareTargetDeclAttr::MT_Enter)) {\n // ...\n SemaRef.Diag(SL, diag::note_var_explicitly_captured_here) << VD << 0 << SR;"}},
[l]={
["clang/test/CXX/expr/expr.prim/expr.prim.lambda/expr.prim.lambda.capture/p5.cpp"]={"clang/test/CXX/expr/expr.prim/expr.prim.lambda/expr.prim.lambda.capture/p5.cpp:5:13: note: variable \'x\' is explicitly captured here"}
}
},
["note_var_fixit_add_initialization"]={
[g]="note_var_fixit_add_initialization",
[b]="initialize the variable %0 to silence this warning",
[c]="initialize the variable A to silence this warning",
[d]=R,
[e]="initialize the variable (.*?) to silence this warning",
[f]=r,
[h]=n,
[a]={"2959fdd087e7",1295638906,"Add basic fixits for -Wuninitialized-experimental","Add basic fixits for -Wuninitialized-experimental\nto suggest initializations for pointer and\nObjC pointer types.\n\nllvm-svn: 123995"},
[i]={{M,797,"static bool SuggestInitializationFixit(Sema &S, const VarDecl *VD) {\n // ...\n S.Diag(Loc, diag::note_var_fixit_add_initialization) << VD->getDeclName() << FixItHint::CreateInsertion(Loc, Init);"}},
[l]={
["clang/test/Analysis/uninit-asm-goto.cpp"]={"clang/test/Analysis/uninit-asm-goto.cpp:104:8: note: initialize the variable \'y\' to silence this warning"}
}
},
["note_var_prev_partial_spec_here"]={
[g]="note_var_prev_partial_spec_here",
[b]="previous declaration of variable template partial specialization is here",
[c]="previous declaration of variable template partial specialization is here",
[d]=R,
[e]="previous declaration of variable template partial specialization is here",
[f]=r,
[h]=n,
[a]={"39a1e507ff0b",1375750985,"Started implementing variable templates. Top level declarations should be fully supported, up to som...","Started implementing variable templates. Top level declarations should be fully supported, up to some limitations documented as FIXMEs or TODO. Static data member templates work very partially. Static data member templates of class templates need particular attention...\n\nllvm-svn: 187762"},
[i]={{"clang/lib/Sema/SemaTemplateInstantiateDecl.cpp",4370,"/// Instantiate the declaration of a variable template partial\n/// specialization.\n///\n/// \\param VarTemplate the (instantiated) variable template that is partially\n/// specialized by the instantiation of \\p PartialSpec.\n///\n/// \\param PartialSpec the (uninstantiated) variable template partial\n/// specialization that we are instantiating.\n///\n/// \\returns The instantiated partial specialization, if successful; otherwise,\n/// NULL to indicate an error.\nVarTemplatePartialSpecializationDecl *TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec) {\n // ...\n if (PrevDecl) {\n // ...\n SemaRef.Diag(PrevDecl->getLocation(), diag::note_var_prev_partial_spec_here);"}}
},
["note_vbase_moved_here"]={
[g]="note_vbase_moved_here",
[b]="%select{%1 is a virtual base class of base class %2 declared here|virtual base class %1 declared here}0",
[c]={{nil,nil,{{"B is a virtual base class of base class C declared here","virtual base class B declared here"}}}},
[d]=R,
[e]="(?:(.*?) is a virtual base class of base class (.*?) declared here|virtual base class (.*?) declared here)",
[f]=r,
[h]=n,
[a]={"b2504bdc0d0e",1383539174,"Issue a diagnostic if an implicitly-defined move assignment operator would move","Issue a diagnostic if an implicitly-defined move assignment operator would move\nthe same virtual base class multiple times (and the move assignment is used,\nand the move assignment for the virtual base is not trivial).\n\nllvm-svn: 193977"},
[i]={{C,15085,"/// Check if we\'re implicitly defining a move assignment operator for a class\n/// with virtual bases. Such a move assignment might move-assign the virtual\n/// base multiple times.\nstatic void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation) {\n // ...\n for (auto &BI : Class->bases()) {\n // ...\n while (!Worklist.empty()) {\n // ...\n if (BaseSpec->isVirtual()) {\n // ...\n if (Existing && Existing != &BI) {\n // ...\n S.Diag(Existing->getBeginLoc(), diag::note_vbase_moved_here) << (Base->getCanonicalDecl() == Existing->getType()->getAsCXXRecordDecl()->getCanonicalDecl()) << Base << Existing->getType() << Existing->getSourceRange();"},{C,15089,"/// Check if we\'re implicitly defining a move assignment operator for a class\n/// with virtual bases. Such a move assignment might move-assign the virtual\n/// base multiple times.\nstatic void checkMoveAssignmentForRepeatedMove(Sema &S, CXXRecordDecl *Class, SourceLocation CurrentLocation) {\n // ...\n for (auto &BI : Class->bases()) {\n // ...\n while (!Worklist.empty()) {\n // ...\n if (BaseSpec->isVirtual()) {\n // ...\n if (Existing && Existing != &BI) {\n // ...\n S.Diag(BI.getBeginLoc(), diag::note_vbase_moved_here) << (Base->getCanonicalDecl() == BI.getType()->getAsCXXRecordDecl()->getCanonicalDecl()) << Base << BI.getType() << BaseSpec->getSourceRange();"}},
[l]={
["clang/test/CXX/special/class.copy/implicit-move.cpp"]={"clang/test/CXX/special/class.copy/implicit-move.cpp:261:7: note: \'B\' is a virtual base class of base class \'E<B, 0>\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:262:7: note: \'B\' is a virtual base class of base class \'E<B, 1>\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:261:7: note: \'D\' is a virtual base class of base class \'E<D, 0>\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:262:7: note: \'D\' is a virtual base class of base class \'E<D, 1>\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:275:7: note: \'B\' is a virtual base class of base class \'E<B, 0>\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:276:7: note: virtual base class \'B\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:275:7: note: \'D\' is a virtual base class of base class \'E<D, 0>\' declared here","clang/test/CXX/special/class.copy/implicit-move.cpp:276:7: note: virtual base class \'D\' declared here"}
}
},
["note_verify_ambiguous_marker"]={
[g]={{nil,B,"note_verify_ambiguous_marker"}},
[b]={{nil,B,"ambiguous marker \'%0\' is defined here"}},
[c]={{nil,B,"ambiguous marker \'A\' is defined here"}},
[d]=R,
[e]="ambiguous marker \'(.*?)\' is defined here",
[f]=r,
[h]={{nil,B,O}},
[a]={"4e8144a0d140",1555130019,"[verify] Add support for location markers in directives.","[verify] Add support for location markers in directives.\n\nA marker (matching /#[A-Za-z0-9_-]/) is specified by attaching a comment\ncontaining the marker to the line at which the diagnostic is expected,\nand then can be referenced from an expected-* directive after an @:\n\n foo // #1\n // expected-error@#1 {{undeclared identifier \'foo\'}}\n\nThe intent is for markers to be used in situations where relative line\nnumbers are currently used, to avoid the need to renumber when the test\ncase is rearranged.\n\nllvm-svn: 358326"},
[i]={{"clang/lib/Frontend/VerifyDiagnosticConsumer.cpp",387,"// Tracker for markers in the input files. A marker is a comment of the form\n//\n// n = 123; // #123\n//\n// ... that can be referred to by a later expected-* directive:\n//\n// // expected-error@#123 {{undeclared identifier \'n\'}}\n//\n// Marker declarations must be at the start of a comment or preceded by\n// whitespace to distinguish them from uses of markers in directives.\nclass VerifyDiagnosticConsumer::MarkerTracker {\n // ...\n // Ensure we have no remaining deferred directives, and no\n // multiply-defined-and-used markers.\n void finalize() {\n for (auto &MarkerInfo : Markers) {\n // ...\n if (M.RedefLoc.isValid() && M.UseLoc.isValid()) {\n // ...\n Diags.Report(M.DefLoc, diag::note_verify_ambiguous_marker) << Name;"},{"clang/lib/Frontend/VerifyDiagnosticConsumer.cpp",388,"// Tracker for markers in the input files. A marker is a comment of the form\n//\n// n = 123; // #123\n//\n// ... that can be referred to by a later expected-* directive:\n//\n// // expected-error@#123 {{undeclared identifier \'n\'}}\n//\n// Marker declarations must be at the start of a comment or preceded by\n// whitespace to distinguish them from uses of markers in directives.\nclass VerifyDiagnosticConsumer::MarkerTracker {\n // ...\n // Ensure we have no remaining deferred directives, and no\n // multiply-defined-and-used markers.\n void finalize() {\n for (auto &MarkerInfo : Markers) {\n // ...\n if (M.RedefLoc.isValid() && M.UseLoc.isValid()) {\n // ...\n Diags.Report(M.RedefLoc, diag::note_verify_ambiguous_marker) << Name;"}}
},
["note_vla_unsupported"]={
[g]={{nil,N,"note_vla_unsupported"}},
[b]={{nil,N,"variable length arrays are not supported for the current target"}},
[c]={{nil,N,"variable length arrays are not supported for the current target"}},
[d]=R,
[e]="variable length arrays are not supported for the current target",
[f]=r,
[h]={{nil,N,n}},
[a]={"87d44269885f",1511038846,"[OpenMP] Show error if VLAs are not supported","[OpenMP] Show error if VLAs are not supported\n\nSome target devices (e.g. Nvidia GPUs) don\'t support dynamic stack\nallocation and hence no VLAs. Print errors with description instead\nof failing in the backend or generating code that doesn\'t work.\n\nThis patch handles explicit uses of VLAs (local variable in target\nor declare target region) or implicitly generated (private) VLAs\nfor reductions on VLAs or on array sections with non-constant size.\n\nDifferential Revision: https://reviews.llvm.org/D39505\n\nllvm-svn: 318601"},
[i]={{"clang/lib/Sema/SemaOpenMP.cpp",19504,"static bool actOnOMPReductionKindClause(Sema &S, DSAStackTy *Stack, OpenMPClauseKind ClauseKind, ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef<Expr *> UnresolvedReductions, ReductionData &RD) {\n // ...\n for (Expr *RefExpr : VarList) {\n // ...\n if ((OASE && !ConstantLengthOASE) || (!OASE && !ASE && D->getType().getNonReferenceType()->isVariablyModifiedType())) {\n if (!Context.getTargetInfo().isVLASupported()) {\n if (isOpenMPTargetExecutionDirective(Stack->getCurrentDirective())) {\n // ...\n S.Diag(ELoc, diag::note_vla_unsupported);"},{"clang/lib/Sema/SemaOpenMP.cpp",19508,"static bool actOnOMPReductionKindClause(Sema &S, DSAStackTy *Stack, OpenMPClauseKind ClauseKind, ArrayRef<Expr *> VarList, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation ColonLoc, SourceLocation EndLoc, CXXScopeSpec &ReductionIdScopeSpec, const DeclarationNameInfo &ReductionId, ArrayRef<Expr *> UnresolvedReductions, ReductionData &RD) {\n // ...\n for (Expr *RefExpr : VarList) {\n // ...\n if ((OASE && !ConstantLengthOASE) || (!OASE && !ASE && D->getType().getNonReferenceType()->isVariablyModifiedType())) {\n if (!Context.getTargetInfo().isVLASupported()) {\n if (isOpenMPTargetExecutionDirective(Stack->getCurrentDirective())) {\n // ...\n } else {\n // ...\n S.targetDiag(ELoc, diag::note_vla_unsupported);"}},
[l]={
["clang/test/OpenMP/target_vla_messages.cpp"]={"clang/test/OpenMP/target_vla_messages.cpp:40:35: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:95:32: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:111:32: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:119:32: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:136:35: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:152:35: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:160:35: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:179:30: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:198:30: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:207:30: note: variable length arrays are not supported for the current target","clang/test/OpenMP/target_vla_messages.cpp:213:34: note: variable length arrays are not supported for the current target"}
}
},
["note_which_delegates_to"]={
[g]="note_which_delegates_to",
[b]="which delegates to",
[c]="which delegates to",
[d]=R,
[e]="which delegates to",
[f]=r,
[h]=n,
[a]={"6118d6642b8f",1304488644,"Implement a better version of delegating constructor cycle detection.","Implement a better version of delegating constructor cycle detection.\n\nThis is more efficient as it\'s all done at once at the end of the TU.\nThis could still get expensive, so a flag is provided to disable it. As\nan added bonus, the diagnostics will now print out a cycle.\n\nThe PCH test is XFAILed because we currently can\'t deal with a note\nemitted in the header and I, being tired, see no other way to verify the\nserialization of delegating constructors. We should probably address\nthis problem /somehow/ but no good solution comes to mind.\n\nllvm-svn: 130836"},
[i]={{C,18554,"static void DelegatingCycleHelper(CXXConstructorDecl *Ctor, llvm::SmallPtrSet<CXXConstructorDecl *, 4> &Valid, llvm::SmallPtrSet<CXXConstructorDecl *, 4> &Invalid, llvm::SmallPtrSet<CXXConstructorDecl *, 4> &Current, Sema &S) {\n // ...\n // We know that beyond here, we aren\'t chaining into a cycle.\n if (!Target || !Target->isDelegatingConstructor() || Target->isInvalidDecl() || Valid.count(TCanonical)) {\n // ...\n } else if (TCanonical == Canonical || Invalid.count(TCanonical) || Current.count(TCanonical)) {\n // If we haven\'t diagnosed this cycle yet, do so now.\n if (!Invalid.count(TCanonical)) {\n // ...\n while (C->getCanonicalDecl() != Canonical) {\n // ...\n S.Diag(C->getLocation(), diag::note_which_delegates_to);"}},
[l]={
["clang/test/SemaCXX/cxx0x-delegating-ctors.cpp"]={"clang/test/SemaCXX/cxx0x-delegating-ctors.cpp:32:6: note: which delegates to"}
}
},
["note_while_in_implementation"]={
[g]="note_while_in_implementation",
[b]="detected while default synthesizing properties in class implementation",
[c]="detected while default synthesizing properties in class implementation",
[d]=R,
[e]="detected while default synthesizing properties in class implementation",
[f]=r,
[h]=n,
[a]={"d6886e7fad5e",1336500219,"Fixes a typo. note_xxx not not_xxx.","Fixes a typo. note_xxx not not_xxx.\n\nllvm-svn: 156391"},
[i]={{pb,1960,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n // ...\n for (const auto &PropEntry : PropMap) {\n // ...\n // If property to be implemented in the super class, ignore.\n if (PropInSuperClass) {\n if ((Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_readwrite) && (PropInSuperClass->getPropertyAttributes() & ObjCPropertyAttribute::kind_readonly) && !IMPDecl->getInstanceMethod(Prop->getSetterName()) && !IDecl->HasUserDeclaredSetterMethod(Prop)) {\n // ...\n } else {\n // ...\n Diag(IMPDecl->getLocation(), diag::note_while_in_implementation);"},{pb,1976,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n // ...\n for (const auto &PropEntry : PropMap) {\n // ...\n if (PIDecl && !Prop->isUnavailable()) {\n // ...\n Diag(IMPDecl->getLocation(), diag::note_while_in_implementation);"}},
[l]={
["clang/test/SemaObjC/super-property-notation.m"]={"clang/test/SemaObjC/super-property-notation.m:47:17: note: detected while default synthesizing properties in class implementation"}
}
},
["note_widen_bitfield"]={
[g]={{nil,E,"note_widen_bitfield"}},
[b]={{nil,E,"widen this field to %0 bits to store all values of %1"}},
[c]={{nil,E,"widen this field to A bits to store all values of B"}},
[d]=R,
[e]="widen this field to (.*?) bits to store all values of (.*?)",
[f]=r,
[h]={{nil,E,n}},
[a]={"329f24d6f6e7",1489514462,"Warn on enum assignment to bitfields that can\'t fit all values","Warn on enum assignment to bitfields that can\'t fit all values\n\nThis adds -Wbitfield-enum-conversion, which warns on implicit\nconversions that happen on bitfield assignment that change the value of\nsome enumerators.\n\nValues of enum type typically take on a very small range of values, so\nthey are frequently stored in bitfields. Unfortunately, there is no\nconvenient way to calculate the minimum number of bits necessary to\nstore all possible values at compile time, so users usually hard code a\nbitwidth that works today and widen it as necessary to pass basic\ntesting and validation. This is very error-prone, and leads to stale\nwidths as enums grow. This warning aims to catch such bugs.\n\nThis would have found two real bugs in clang and two instances of\nquestionable code. See r297680 and r297654 for the full description of\nthe issues.\n\nThis warning is currently disabled by default while we investigate its\nusefulness outside of LLVM.\n\nThe major cause of false positives with this warning is this kind of\nenum:\n enum E { W, X, Y, Z, SENTINEL_LAST };\nThe last enumerator is an invalid value used to validate inputs or size\nan array. Depending on the prevalance of this style of enum across a\ncodebase, this warning may be more or less feasible to deploy. It also\nhas trouble on sentinel values such as ~0U.\n\nReviewers: rsmith, rtrieu, thakis\n\nReviewed By: thakis\n\nSubscribers: hfinkel, voskresensky.vladimir, sashab, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D30923\n\nllvm-svn: 297761"},
[i]={{u,14111,"/// Analyzes an attempt to assign the given value to a bitfield.\n///\n/// Returns true if there was something fishy about the attempt.\nstatic bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc) {\n // ...\n if (!OriginalInit->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects)) {\n // The RHS is not constant. If the RHS has an enum type, make sure the\n // bitfield is wide enough to hold all the values of the enum without\n // truncation.\n if (const auto *EnumTy = OriginalInit->getType()->getAs<EnumType>()) {\n // ...\n // Check the bitwidth.\n if (BitsNeeded > FieldWidth) {\n // ...\n S.Diag(WidthExpr->getExprLoc(), diag::note_widen_bitfield) << BitsNeeded << ED << WidthExpr->getSourceRange();"}},
[l]={
["clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp"]={"clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:11:23: note: widen this field to 3 bits to store all values of \'ThreeBits\'","clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:11:23: note: widen this field to 3 bits to store all values of \'ThreeBitsSigned\'","clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:12:25: note: widen this field to 3 bits to store all values of \'ThreeBits\'","clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:12:25: note: widen this field to 3 bits to store all values of \'ThreeBitsSigned\'"}
}
},
["note_within_field_of_type"]={
[g]="note_within_field_of_type",
[b]="within field of type %0 declared here",
[c]="within field of type A declared here",
[d]=R,
[e]="within field of type (.*?) declared here",
[f]=r,
[h]=n,
[a]={"efb38192b0b2",1374542616,"Error on more illegal kernel argument types for OpenCL","Error on more illegal kernel argument types for OpenCL\n\nbool, half, pointers and structs / unions containing any\nof these are not allowed. Does not yet reject size_t and\nrelated integer types that are also disallowed.\n\nllvm-svn: 186908"},
[i]={{H,9585,"static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {\n // ...\n do {\n // ...\n for (const auto *FD : RD->fields()) {\n // ...\n S.Diag(OrigRecDecl->getLocation(), diag::note_within_field_of_type) << OrigRecDecl->getDeclName();"},{H,9595,"static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {\n // ...\n do {\n // ...\n for (const auto *FD : RD->fields()) {\n // ...\n // We have an error, now let\'s go back up through history and show where\n // the offending field came from\n for (ArrayRef<const FieldDecl *>::const_iterator I = HistoryStack.begin() + 1, E = HistoryStack.end(); I != E; ++I) {\n // ...\n S.Diag(OuterField->getLocation(), diag::note_within_field_of_type) << OuterField->getType();"},{"clang/lib/Sema/SemaSYCL.cpp",98,"void Sema::deepTypeCheckForSYCLDevice(SourceLocation UsedAt, llvm::DenseSet<QualType> Visited, ValueDecl *DeclToCheck) {\n // ...\n do {\n // ...\n auto EmitHistory = [&]() {\n // The first element is always nullptr.\n for (uint64_t Index = 1; Index < History.size(); ++Index) {\n SYCLDiagIfDeviceCode(History[Index]->getLocation(), diag::note_within_field_of_type) << History[Index]->getType();"}},
[l]={
["clang/test/SemaSYCL/zero-length-arrays.cpp"]={"clang/test/SemaSYCL/zero-length-arrays.cpp:84:11: note: within field of type \'WrapperOfWrapper\' declared here","clang/test/SemaSYCL/zero-length-arrays.cpp:89:32: note: within field of type \'WrapperOfWrapper\' declared here","clang/test/SemaSYCL/zero-length-arrays.cpp:101:13: note: within field of type \'Templated<1 - 1, double>\' declared here",Pb,"clang/test/SemaSYCL/zero-length-arrays.cpp:108:32: note: within field of type \'Templated<0, float>\' declared here",Pb,"clang/test/SemaSYCL/zero-length-arrays.cpp:53:11: note: within field of type \'Templated<0U, float>\' declared here",Pb,"clang/test/SemaSYCL/zero-length-arrays.cpp:58:31: note: within field of type \'Templated<0U, float>\' declared here",Pb,"clang/test/SemaSYCL/zero-length-arrays.cpp:20:11: note: within field of type \'Wrapper\' declared here",Pb,Pb,Pb,Pb,"clang/test/SemaSYCL/zero-length-arrays.cpp:20:11: note: within field of type \'Wrapper\' declared here"}
}
},
["note_xor_used_as_pow_silence"]={
[g]={{nil,s,"note_xor_used_as_pow_silence"}},
[b]={{nil,s,"replace expression with \'%0\' %select{|or use \'xor\' instead of \'^\' }1to silence this warning"}},
[c]={{nil,s,{"replace expression with \'A\' ",{r,"or use \'xor\' instead of \'^\' "},"to silence this warning"}}},
[d]=R,
[e]="replace expression with \'(.*?)\' (?:|or use \'xor\' instead of \'\\^\' )to silence this warning",
[f]=r,
[h]={{nil,s,n}},
[a]={"920890e26812",1566155654,"[Diagnostics] Diagnose misused xor as pow","[Diagnostics] Diagnose misused xor as pow\n\nSummary:\nMotivation:\nhttps://twitter.com/jfbastien/status/1139298419988549632\nhttps://twitter.com/mikemx7f/status/1139335901790625793\nhttps://codesearch.isocpp.org/cgi-bin/cgi_ppsearch?q=10+%5E&search=Search\n\nReviewers: jfb, rsmith, regehr, aaron.ballman\n\nReviewed By: aaron.ballman\n\nSubscribers: lebedev.ri, Quuxplusone, erik.pilkington, riccibruno, dexonsmith, cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D63423\n\nllvm-svn: 369217"},
[i]={{G,13691,"static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS, const ExprResult &XorRHS, const SourceLocation Loc) {\n // ...\n if (LeftSideValue == 2 && RightSideIntValue >= 0) {\n // ...\n S.Diag(Loc, diag::note_xor_used_as_pow_silence) << (\"0x2 ^ \" + RHSStr) << SuggestXor;"},{G,13903,"static void diagnoseXorMisusedAsPow(Sema &S, const ExprResult &XorLHS, const ExprResult &XorRHS, const SourceLocation Loc) {\n // ...\n if (LeftSideValue == 2 && RightSideIntValue >= 0) {\n // ...\n } else if (LeftSideValue == 10) {\n // ...\n S.Diag(Loc, diag::note_xor_used_as_pow_silence) << (\"0xA ^ \" + RHSStr) << SuggestXor;"}},
[l]={
["clang/test/SemaCXX/warn-xor-as-pow.cpp"]={"clang/test/SemaCXX/warn-xor-as-pow.cpp:36:11: note: replace expression with \'0x2 ^ 0\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:39:11: note: replace expression with \'0x2 ^ 1\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:42:11: note: replace expression with \'0x2 ^ 2\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:45:11: note: replace expression with \'0x2 ^ 8\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:48:11: note: replace expression with \'0x2 ^ +8\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:51:13: note: replace expression with \'0x2 ^ 8\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:54:11: note: replace expression with \'0x2 ^ 16\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:57:11: note: replace expression with \'0x2 ^ TEN\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:60:18: note: replace expression with \'0x2 ^ ALPHA_OFFSET\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:80:11: note: replace expression with \'0x2 ^ 32\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:83:11: note: replace expression with \'0x2 ^ 64\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:88:12: note: replace expression with \'0xA ^ 0\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:91:12: note: replace expression with \'0xA ^ 1\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:94:12: note: replace expression with \'0xA ^ 2\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:97:12: note: replace expression with \'0xA ^ 4\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:100:12: note: replace expression with \'0xA ^ +4\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:103:12: note: replace expression with \'0xA ^ 10\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:106:13: note: replace expression with \'0xA ^ 10\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:109:12: note: replace expression with \'0xA ^ TEN\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:112:12: note: replace expression with \'0xA ^ 100\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:116:12: note: replace expression with \'0xA ^ -EXP\' or use \'xor\' instead of \'^\' to silence this warning","clang/test/SemaCXX/warn-xor-as-pow.cpp:119:12: note: replace expression with \'0xA ^ +EXP\' or use \'xor\' instead of \'^\' to silence this warning"}
}
},
["null_in_char_or_string"]={
[j]={"null-character"},
[k]="null-character",
[g]="null_in_char_or_string",
[b]="null character(s) preserved in %select{char|string}0 literal",
[c]={{nil,nil,{"null character(s) preserved in ",{"char","string"}," literal"}}},
[d]=m,
[e]="null character\\(s\\) preserved in (?:char|string) literal",
[f]=" \\[(?:\\-Werror,)?\\-Wnull\\-character[^\\]]*\\]",
[h]=A,
[a]={"7f5ff2175f68",1447466995,"Use %select to merge similar diagnostics. NFC","Use %select to merge similar diagnostics. NFC\n\nllvm-svn: 253119"},
[i]={{bb,2127,"/// LexStringLiteral - Lex the remainder of a string literal, after having lexed\n/// either \" or L\" or u8\" or u\" or U\".\nbool Lexer::LexStringLiteral(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n // ...\n // If a nul character existed in the string, warn about it.\n if (NulCharacter && !isLexingRawMode())\n Diag(NulCharacter, diag::null_in_char_or_string) << 1;"},{bb,2251,"/// LexAngledStringLiteral - Lex the remainder of an angled string literal,\n/// after having lexed the \'<\' character. This is used for #include filenames.\nbool Lexer::LexAngledStringLiteral(Token &Result, const char *CurPtr) {\n // ...\n // If a nul character existed in the string, warn about it.\n if (NulCharacter && !isLexingRawMode())\n Diag(NulCharacter, diag::null_in_char_or_string) << 1;"},{bb,2349,"/// LexCharConstant - Lex the remainder of a character constant, after having\n/// lexed either \' or L\' or u8\' or u\' or U\'.\nbool Lexer::LexCharConstant(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n // ...\n // If a nul character existed in the character, warn about it.\n if (NulCharacter && !isLexingRawMode())\n Diag(NulCharacter, diag::null_in_char_or_string) << 0;"}},
[l]={
["clang/test/Lexer/null-character-in-literal.c"]={"clang/test/Lexer/null-character-in-literal.c:6:11: warning: null character(s) preserved in char literal [-Wnull-character]","clang/test/Lexer/null-character-in-literal.c:7:12: warning: null character(s) preserved in char literal [-Wnull-character]","clang/test/Lexer/null-character-in-literal.c:10:16: warning: null character(s) preserved in string literal [-Wnull-character]","clang/test/Lexer/null-character-in-literal.c:11:17: warning: null character(s) preserved in string literal [-Wnull-character]","clang/test/Lexer/null-character-in-literal.c:15:16: warning: null character(s) preserved in string literal [-Wnull-character]"}
}
},
["null_in_file"]={
[j]={"null-character"},
[k]="null-character",
[g]="null_in_file",
[b]="null character ignored",
[c]="null character ignored",
[d]=m,
[e]="null character ignored",
[f]=" \\[(?:\\-Werror,)?\\-Wnull\\-character[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{bb,3641,"LexStart:\n // ...\n case 0: // Null.\n // ...\n if (!isLexingRawMode())\n Diag(CurPtr - 1, diag::null_in_file);"}},
[l]={
["clang/test/Lexer/newline-nul.c"]={"clang/test/Lexer/newline-nul.c:6:1: warning: null character ignored [-Wnull-character]"}
}
},
["override_keyword_hides_virtual_member_function"]={
[g]="override_keyword_hides_virtual_member_function",
[b]="non-virtual member function marked \'%0\' hides virtual member %select{function|functions}1",
[c]={{nil,nil,{"non-virtual member function marked \'A\' hides virtual member ",{sc,Kb}}}},
[d]=Qb,
[e]="non\\-virtual member function marked \'(.*?)\' hides virtual member (?:function|functions)",
[f]=r,
[h]=n,
[a]={"af65120bd382",1378425063,"Improve error for \"override\" + non-virtual func.","Improve error for \"override\" + non-virtual func.\n\nConsider something like the following:\n\nstruct X {\n virtual void foo(float x);\n};\nstruct Y : X {\n void foo(double x) override;\n};\n\nThe error is almost certainly that Y::foo() has the wrong signature,\nrather than incorrect usage of the override keyword. This patch\nadds an appropriate diagnostic for that case.\n\nFixes <rdar://problem/14785106>.\n\nllvm-svn: 190109"},
[i]={{C,3244,"/// CheckOverrideControl - Check C++11 override control semantics.\nvoid Sema::CheckOverrideControl(NamedDecl *D) {\n // ...\n if (MD && !MD->isVirtual()) {\n // ...\n if (!OverloadedMethods.empty()) {\n if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {\n Diag(OA->getLocation(), diag::override_keyword_hides_virtual_member_function) << \"override\" << (OverloadedMethods.size() > 1);"},{C,3248,"/// CheckOverrideControl - Check C++11 override control semantics.\nvoid Sema::CheckOverrideControl(NamedDecl *D) {\n // ...\n if (MD && !MD->isVirtual()) {\n // ...\n if (!OverloadedMethods.empty()) {\n if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {\n // ...\n } else if (FinalAttr *FA = D->getAttr<FinalAttr>()) {\n Diag(FA->getLocation(), diag::override_keyword_hides_virtual_member_function) << (FA->isSpelledAsSealed() ? \"sealed\" : \"final\") << (OverloadedMethods.size() > 1);"}},
[l]={
["clang/test/SemaCXX/pass-object-size.cpp"]={"clang/test/SemaCXX/pass-object-size.cpp:89:28: error: non-virtual member function marked \'override\' hides virtual member function"}
}
},
["override_keyword_only_allowed_on_virtual_member_functions"]={
[g]="override_keyword_only_allowed_on_virtual_member_functions",
[b]="only virtual member functions can be marked \'%0\'",
[c]="only virtual member functions can be marked \'A\'",
[d]=Qb,
[e]="only virtual member functions can be marked \'(.*?)\'",
[f]=r,
[h]=n,
[a]={"13a69102d779",1295498062,"Only allow virtual member functions to be marked \'override\' and \'final\'.","Only allow virtual member functions to be marked \'override\' and \'final\'.\n\nllvm-svn: 123882"},
[i]={{C,3263,"/// CheckOverrideControl - Check C++11 override control semantics.\nvoid Sema::CheckOverrideControl(NamedDecl *D) {\n // ...\n if (!MD || !MD->isVirtual()) {\n if (OverrideAttr *OA = D->getAttr<OverrideAttr>()) {\n Diag(OA->getLocation(), diag::override_keyword_only_allowed_on_virtual_member_functions) << \"override\" << FixItHint::CreateRemoval(OA->getLocation());"},{C,3269,"/// CheckOverrideControl - Check C++11 override control semantics.\nvoid Sema::CheckOverrideControl(NamedDecl *D) {\n // ...\n if (!MD || !MD->isVirtual()) {\n // ...\n if (FinalAttr *FA = D->getAttr<FinalAttr>()) {\n Diag(FA->getLocation(), diag::override_keyword_only_allowed_on_virtual_member_functions) << (FA->isSpelledAsSealed() ? \"sealed\" : \"final\") << FixItHint::CreateRemoval(FA->getLocation());"}},
[l]={
["clang/test/CXX/class/class.mem/p8-0x.cpp"]={"clang/test/CXX/class/class.mem/p8-0x.cpp:20:12: error: only virtual member functions can be marked \'override\'","clang/test/CXX/class/class.mem/p8-0x.cpp:21:9: error: only virtual member functions can be marked \'override\'","clang/test/CXX/class/class.mem/p8-0x.cpp:26:12: error: only virtual member functions can be marked \'final\'","clang/test/CXX/class/class.mem/p8-0x.cpp:27:9: error: only virtual member functions can be marked \'final\'","clang/test/CXX/class/class.mem/p8-0x.cpp:46:14: error: only virtual member functions can be marked \'override\'","clang/test/CXX/class/class.mem/p8-0x.cpp:51:14: error: only virtual member functions can be marked \'final\'"}
}
},
["pp_disabled_macro_expansion"]={
[j]={"disabled-macro-expansion"},
[k]="disabled-macro-expansion",
[g]="pp_disabled_macro_expansion",
[b]="disabled expansion of recursive macro",
[c]="disabled expansion of recursive macro",
[d]=m,
[e]="disabled expansion of recursive macro",
[f]=" \\[(?:\\-Werror,)?\\-Wdisabled\\-macro\\-expansion[^\\]]*\\]",
[h]=A,
[a]={"123bec89ab8f",1325455264,"Added -Wdisabled-macro-expansion warning.","Added -Wdisabled-macro-expansion warning.\n\nllvm-svn: 147418"},
[i]={{"clang/lib/Lex/PPMacroExpansion.cpp",622,"/// HandleMacroExpandedIdentifier - If an identifier token is read that is to be\n/// expanded as a macro, handle it and return the next token as \'Identifier\'.\nbool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier, const MacroDefinition &M) {\n // ...\n // If this macro expands to no tokens, don\'t bother to push it onto the\n // expansion stack, only to take it right back off.\n if (MI->getNumTokens() == 0) {\n // ...\n } else if (MI->getNumTokens() == 1 && isTrivialSingleTokenExpansion(MI, Identifier.getIdentifierInfo(), *this)) {\n // ...\n // If this is a disabled macro or #define X X, we must mark the result as\n // unexpandable.\n if (IdentifierInfo *NewII = Identifier.getIdentifierInfo()) {\n if (MacroInfo *NewMI = getMacroInfo(NewII))\n if (!NewMI->isEnabled() || NewMI == MI) {\n // ...\n // Don\'t warn for \"#define X X\" like \"#define bool bool\" from\n // stdbool.h.\n if (NewMI != MI || MI->isFunctionLike())\n Diag(Identifier, diag::pp_disabled_macro_expansion);"},{"clang/lib/Lex/Preprocessor.cpp",833,"/// HandleIdentifier - This callback is invoked when the lexer reads an\n/// identifier. This callback looks up the identifier in the map and/or\n/// potentially macro expands it or turns it into a named token (like \'for\').\n///\n/// Note that callers of this method are guarded by checking the\n/// IdentifierInfo\'s \'isHandleIdentifierCase\' bit. If this method changes, the\n/// IdentifierInfo methods that compute these properties will need to change to\n/// match.\nbool Preprocessor::HandleIdentifier(Token &Identifier) {\n // ...\n // If this is a macro to be expanded, do it.\n if (MacroDefinition MD = getMacroDefinition(&II)) {\n // ...\n if (!DisableMacroExpansion) {\n if (!Identifier.isExpandDisabled() && MI->isEnabled()) {\n // ...\n } else {\n // ...\n if (MI->isObjectLike() || isNextPPTokenLParen())\n Diag(Identifier, diag::pp_disabled_macro_expansion);"}},
[l]={
["clang/test/Preprocessor/warn-disabled-macro-expansion.c"]={"clang/test/Preprocessor/warn-disabled-macro-expansion.c:22:1: warning: disabled expansion of recursive macro [-Wdisabled-macro-expansion]","clang/test/Preprocessor/warn-disabled-macro-expansion.c:26:1: warning: disabled expansion of recursive macro [-Wdisabled-macro-expansion]","clang/test/Preprocessor/warn-disabled-macro-expansion.c:28:1: warning: disabled expansion of recursive macro [-Wdisabled-macro-expansion]","clang/test/Preprocessor/warn-disabled-macro-expansion.c:30:3: warning: disabled expansion of recursive macro [-Wdisabled-macro-expansion]","clang/test/Preprocessor/warn-disabled-macro-expansion.c:32:1: warning: disabled expansion of recursive macro [-Wdisabled-macro-expansion]"}
}
},
["pp_err_elif_after_else"]={
[g]="pp_err_elif_after_else",
[b]={{nil,w,"%select{#elif|#elifdef|#elifndef}0 after #else"},{p,nil,"#elif after #else"}},
[c]={{nil,w,{{"#elif","#elifdef","#elifndef"}," after #else"}},{p,nil,"#elif after #else"}},
[d]=Qb,
[e]="(?:\\#elif|\\#elifdef|\\#elifndef) after \\#else",
[f]=r,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,721,"/// SkipExcludedConditionalBlock - We just read a \\#if or related directive and\n/// decided that the subsequent tokens are in the \\#if\'d out portion of the\n/// file. Lex the rest of the file, until we see an \\#endif. If\n/// FoundNonSkipPortion is true, then we have already emitted code for part of\n/// this \\#if directive, so \\#else/\\#elif blocks should never be entered.\n/// If ElseOk is true, then \\#else directives are ok, if not, then we have\n/// already seen one so a \\#else directive is a duplicate. When this returns,\n/// the caller can lex the first valid token.\nvoid Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) {\n // ...\n while (true) {\n // ...\n if (Directive.startswith(\"if\")) {\n // ...\n } else if (Directive[0] == \'e\') {\n // ...\n if (Sub == \"ndif\") { // \"endif\"\n // ...\n } else if (Sub == \"lse\") { // \"else\".\n // ...\n } else if (Sub == \"lif\") { // \"elif\".\n // ...\n // If this is a #elif with a #else before it, report the error.\n if (CondInfo.FoundElse)\n Diag(Tok, diag::pp_err_elif_after_else) << PED_Elif;"},{S,777,"/// SkipExcludedConditionalBlock - We just read a \\#if or related directive and\n/// decided that the subsequent tokens are in the \\#if\'d out portion of the\n/// file. Lex the rest of the file, until we see an \\#endif. If\n/// FoundNonSkipPortion is true, then we have already emitted code for part of\n/// this \\#if directive, so \\#else/\\#elif blocks should never be entered.\n/// If ElseOk is true, then \\#else directives are ok, if not, then we have\n/// already seen one so a \\#else directive is a duplicate. When this returns,\n/// the caller can lex the first valid token.\nvoid Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) {\n // ...\n while (true) {\n // ...\n if (Directive.startswith(\"if\")) {\n // ...\n } else if (Directive[0] == \'e\') {\n // ...\n if (Sub == \"ndif\") { // \"endif\"\n // ...\n } else if (Sub == \"lse\") { // \"else\".\n // ...\n } else if (Sub == \"lif\") { // \"elif\".\n // ...\n } else if (Sub == \"lifdef\" || // \"elifdef\"\n // ...\n // If this is a #elif with a #else before it, report the error.\n if (CondInfo.FoundElse)\n Diag(Tok, diag::pp_err_elif_after_else) << (IsElifDef ? PED_Elifdef : PED_Elifndef);"},{S,3482,"/// Implements the \\#elif, \\#elifdef, and \\#elifndef directives.\nvoid Preprocessor::HandleElifFamilyDirective(Token &ElifToken, const Token &HashToken, tok::PPKeywordKind Kind) {\n // ...\n // If this is a #elif with a #else before it, report the error.\n if (CI.FoundElse)\n Diag(ElifToken, diag::pp_err_elif_after_else) << DirKind;"}},
[l]={
["clang/test/Preprocessor/elifdef.c"]={"clang/test/Preprocessor/elifdef.c:97:2: error: #elifdef after #else","clang/test/Preprocessor/elifdef.c:104:2: error: #elifndef after #else","clang/test/Preprocessor/elifdef.c:129:2: error: #elif after #else"}
}
},
["pp_err_elif_without_if"]={
[g]="pp_err_elif_without_if",
[b]={{nil,w,"%select{#elif|#elifdef|#elifndef}0 without #if"},{p,nil,"#elif without #if"}},
[c]={{nil,w,{{"#elif","#elifdef","#elifndef"}," without #if"}},{p,nil,"#elif without #if"}},
[d]=Qb,
[e]="(?:\\#elif|\\#elifdef|\\#elifndef) without \\#if",
[f]=r,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,3472,"/// Implements the \\#elif, \\#elifdef, and \\#elifndef directives.\nvoid Preprocessor::HandleElifFamilyDirective(Token &ElifToken, const Token &HashToken, tok::PPKeywordKind Kind) {\n // ...\n if (CurPPLexer->popConditionalLevel(CI)) {\n Diag(ElifToken, diag::pp_err_elif_without_if) << DirKind;"}},
[l]={
["clang/test/Preprocessor/elifdef.c"]={"clang/test/Preprocessor/elifdef.c:108:2: error: #elifdef without #if","clang/test/Preprocessor/elifdef.c:112:2: error: #elifndef without #if"}
}
},
["pp_err_else_after_else"]={
[g]="pp_err_else_after_else",
[b]="#else after #else",
[c]="#else after #else",
[d]=Qb,
[e]="\\#else after \\#else",
[f]=r,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,693,"/// SkipExcludedConditionalBlock - We just read a \\#if or related directive and\n/// decided that the subsequent tokens are in the \\#if\'d out portion of the\n/// file. Lex the rest of the file, until we see an \\#endif. If\n/// FoundNonSkipPortion is true, then we have already emitted code for part of\n/// this \\#if directive, so \\#else/\\#elif blocks should never be entered.\n/// If ElseOk is true, then \\#else directives are ok, if not, then we have\n/// already seen one so a \\#else directive is a duplicate. When this returns,\n/// the caller can lex the first valid token.\nvoid Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) {\n // ...\n while (true) {\n // ...\n if (Directive.startswith(\"if\")) {\n // ...\n } else if (Directive[0] == \'e\') {\n // ...\n if (Sub == \"ndif\") { // \"endif\"\n // ...\n } else if (Sub == \"lse\") { // \"else\".\n // ...\n // If this is a #else with a #else before it, report the error.\n if (CondInfo.FoundElse)\n Diag(Tok, diag::pp_err_else_after_else);"},{S,3417,"/// HandleElseDirective - Implements the \\#else directive.\n///\nvoid Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {\n // ...\n // If this is a #else with a #else before it, report the error.\n if (CI.FoundElse)\n Diag(Result, diag::pp_err_else_after_else);"}}
},
["pp_err_else_without_if"]={
[g]="pp_err_else_without_if",
[b]="#else without #if",
[c]="#else without #if",
[d]=Qb,
[e]="\\#else without \\#if",
[f]=r,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,3408,"/// HandleElseDirective - Implements the \\#else directive.\n///\nvoid Preprocessor::HandleElseDirective(Token &Result, const Token &HashToken) {\n // ...\n if (CurPPLexer->popConditionalLevel(CI)) {\n Diag(Result, diag::pp_err_else_without_if);"}}
},
["pp_hash_warning"]={
[j]={"#warnings","cpp"},
[k]="#warnings",
[g]="pp_hash_warning",
[b]=Cc,
[c]=Sb,
[d]=m,
[e]=Ac,
[f]=" \\[(?:\\-Werror,)?\\-W\\#warnings[^\\]]*\\]",
[h]="User-Defined Issue",
[a]={K,1236199783,J,I},
[i]={{S,1656,"/// HandleUserDiagnosticDirective - Handle a #warning or #error directive.\n///\nvoid Preprocessor::HandleUserDiagnosticDirective(Token &Tok, bool isWarning) {\n // ...\n if (isWarning)\n Diag(Tok, diag::pp_hash_warning) << Msg;"},{"clang/unittests/Basic/DiagnosticTest.cpp",149,"TEST(DiagnosticTest, storedDiagEmptyWarning) {\n // ...\n Diags.Report(diag::pp_hash_warning) << \"\";"}},
[l]={
["clang/test/Preprocessor/include-directive3.c"]={"./clang/test/Preprocessor/file_to_include.h:2:2: warning: file successfully included [-W#warnings]"}
}
},
["pp_include_macros_out_of_predefines"]={
[g]="pp_include_macros_out_of_predefines",
[b]="the #__include_macros directive is only for internal use by -imacros",
[c]="the #__include_macros directive is only for internal use by -imacros",
[d]=Qb,
[e]="the \\#__include_macros directive is only for internal use by \\-imacros",
[f]=r,
[h]=A,
[a]={"58a1eb0ba0e0",1239216400,"reject the #__include_macros directive unless it comes from the ","reject the #__include_macros directive unless it comes from the \npredefines buffer.\n\nllvm-svn: 68627"},
[i]={{S,2639,"/// HandleIncludeMacrosDirective - The -imacros command line option turns into a\n/// pseudo directive in the predefines buffer. This handles it by sucking all\n/// tokens through the preprocessor and discarding them (only keeping the side\n/// effects on the preprocessor).\nvoid Preprocessor::HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &IncludeMacrosTok) {\n // ...\n if (SourceMgr.getBufferName(Loc) != \"<built-in>\") {\n Diag(IncludeMacrosTok.getLocation(), diag::pp_include_macros_out_of_predefines);"}}
},
["pp_include_next_absolute_path"]={
[j]={"include-next-absolute-path"},
[k]="include-next-absolute-path",
[g]="pp_include_next_absolute_path",
[b]={{nil,B,"#include_next in file found relative to primary source file or found by absolute path; will search from start of include path"},{V,nil,"#include_next with absolute path"}},
[c]={{nil,B,"#include_next in file found relative to primary source file or found by absolute path; will search from start of include path"},{V,nil,"#include_next with absolute path"}},
[d]=m,
[e]="\\#include_next in file found relative to primary source file or found by absolute path; will search from start of include path",
[f]=" \\[(?:\\-Werror,)?\\-Winclude\\-next\\-absolute\\-path[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,1948,"std::pair<ConstSearchDirIterator, const FileEntry *> Preprocessor::getIncludeNextStart(const Token &IncludeNextTok) const {\n // ...\n if (isInPrimaryFile() && LangOpts.IsHeaderFile) {\n // ...\n } else if (isInPrimaryFile()) {\n // ...\n } else if (CurLexerSubmodule) {\n // ...\n } else if (!Lookup) {\n // ...\n Diag(IncludeNextTok, diag::pp_include_next_absolute_path);"}},
[l]={
["clang/test/Preprocessor/include-next.c"]={"clang/test/Preprocessor/Inputs/include-next-1/foo.h:1:2: warning: #include_next in file found relative to primary source file or found by absolute path; will search from start of include path [-Winclude-next-absolute-path]"}
}
},
["pp_include_next_in_primary"]={
[j]={"include-next-outside-header"},
[k]="include-next-outside-header",
[g]="pp_include_next_in_primary",
[b]={{nil,B,"#include_next in primary source file; will search from start of include path"},{V,nil,"#include_next in primary source file"}},
[c]={{nil,B,"#include_next in primary source file; will search from start of include path"},{V,nil,"#include_next in primary source file"}},
[d]=m,
[e]="\\#include_next in primary source file; will search from start of include path",
[f]=" \\[(?:\\-Werror,)?\\-Winclude\\-next\\-outside\\-header[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,1936,"std::pair<ConstSearchDirIterator, const FileEntry *> Preprocessor::getIncludeNextStart(const Token &IncludeNextTok) const {\n // ...\n if (isInPrimaryFile() && LangOpts.IsHeaderFile) {\n // ...\n } else if (isInPrimaryFile()) {\n // ...\n Diag(IncludeNextTok, diag::pp_include_next_in_primary);"}},
[l]={
["clang/test/Preprocessor/has_include.c"]={"clang/test/Preprocessor/has_include.c:36:5: warning: #include_next in primary source file; will search from start of include path [-Winclude-next-outside-header]","clang/test/Preprocessor/has_include.c:41:5: warning: #include_next in primary source file; will search from start of include path [-Winclude-next-outside-header]","clang/test/Preprocessor/has_include.c:47:6: warning: #include_next in primary source file; will search from start of include path [-Winclude-next-outside-header]","clang/test/Preprocessor/has_include.c:52:5: warning: #include_next in primary source file; will search from start of include path [-Winclude-next-outside-header]","clang/test/Preprocessor/has_include.c:58:5: warning: #include_next in primary source file; will search from start of include path [-Winclude-next-outside-header]","clang/test/Preprocessor/has_include.c:96:3: warning: #include_next in primary source file; will search from start of include path [-Winclude-next-outside-header]"}
}
},
["pp_invalid_string_literal"]={
[g]="pp_invalid_string_literal",
[b]="invalid string literal, ignoring final \'\\\'",
[c]="invalid string literal, ignoring final \'\\\'",
[d]=m,
[e]="invalid string literal, ignoring final \'\\\\\'",
[f]=jb,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{"clang/lib/Lex/MacroArgs.cpp",279,"/// StringifyArgument - Implement C99 6.10.3.2p2, converting a sequence of\n/// tokens into the literal string token that should be produced by the C #\n/// preprocessor operator. If Charify is true, then it should be turned into\n/// a character literal for the Microsoft charize (#@) extension.\n///\nToken MacroArgs::StringifyArgument(const Token *ArgToks, Preprocessor &PP, bool Charify, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd) {\n // ...\n // If the last character of the string is a \\, and if it isn\'t escaped, this\n // is an invalid string literal, diagnose it as specified in C99.\n if (Result.back() == \'\\\\\') {\n // ...\n if ((Result.size() - 1 - FirstNonSlash) & 1) {\n // ...\n PP.Diag(ArgToks[-1], diag::pp_invalid_string_literal);"}}
},
["pp_macro_not_used"]={
[j]={"unused-macros"},
[k]="unused-macros",
[g]="pp_macro_not_used",
[b]="macro is not used",
[c]="macro is not used",
[d]=m,
[e]="macro is not used",
[f]=" \\[(?:\\-Werror,)?\\-Wunused\\-macros[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{S,3131,"/// HandleDefineDirective - Implements \\#define. This consumes the entire macro\n/// line then lets the caller lex the next real token.\nvoid Preprocessor::HandleDefineDirective(Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {\n // ...\n // Finally, if this identifier already had a macro defined for it, verify that\n // the macro bodies are identical, and issue diagnostics if they are not.\n if (const MacroInfo *OtherMI = getMacroInfo(MacroNameTok.getIdentifierInfo())) {\n // ...\n // It is very common for system headers to have tons of macro redefinitions\n // and for warnings to be disabled in system headers. If this is the case,\n // then don\'t bother calling MacroInfo::isIdenticalTo.\n if (!getDiagnostics().getSuppressSystemWarnings() || !SourceMgr.isInSystemHeader(DefineTok.getLocation())) {\n if (!OtherMI->isUsed() && OtherMI->isWarnIfUnused())\n Diag(OtherMI->getDefinitionLoc(), diag::pp_macro_not_used);"},{S,3157,"/// HandleDefineDirective - Implements \\#define. This consumes the entire macro\n/// line then lets the caller lex the next real token.\nvoid Preprocessor::HandleDefineDirective(Token &DefineTok, const bool ImmediatelyAfterHeaderGuard) {\n // ...\n if (getSourceManager().isInMainFile(MI->getDefinitionLoc()) && !Diags->isIgnored(diag::pp_macro_not_used, MI->getDefinitionLoc()) && !MacroExpansionInDirectivesOverride && getSourceManager().getFileID(MI->getDefinitionLoc()) != getPredefinesFileID()) {"},{S,3213,"/// HandleUndefDirective - Implements \\#undef.\n///\nvoid Preprocessor::HandleUndefDirective() {\n // ...\n // If the macro is not defined, this is a noop undef.\n if (const MacroInfo *MI = MD.getMacroInfo()) {\n if (!MI->isUsed() && MI->isWarnIfUnused())\n Diag(MI->getDefinitionLoc(), diag::pp_macro_not_used);"},{"clang/lib/Lex/PPLexerChange.cpp",584,"/// HandleEndOfFile - This callback is invoked when the lexer hits the end of\n/// the current file. This either returns the EOF token or pops a level off\n/// the include stack and keeps going.\nbool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {\n // ...\n if (TUKind == TU_Complete) {\n // This is the end of the top-level file. \'WarnUnusedMacroLocs\' has\n // collected all macro locations that we need to warn because they are not\n // used.\n for (WarnUnusedMacroLocsTy::iterator I = WarnUnusedMacroLocs.begin(), E = WarnUnusedMacroLocs.end(); I != E; ++I)\n Diag(*I, diag::pp_macro_not_used);"}},
[l]={
["clang/test/Preprocessor/Weverything_pragma.c"]={"clang/test/Preprocessor/Weverything_pragma.c:16:9: warning: macro is not used [-Wunused-macros]","clang/test/Preprocessor/Weverything_pragma.c:7:9: warning: macro is not used [-Wunused-macros]","clang/test/Preprocessor/Weverything_pragma.c:24:9: warning: macro is not used [-Wunused-macros]","clang/test/Preprocessor/Weverything_pragma.c:28:9: error: macro is not used [-Werror,-Wunused-macros]"}
}
},
["pp_nonportable_path"]={
[j]={"nonportable-include-path"},
[k]="nonportable-include-path",
[g]="pp_nonportable_path",
[b]="non-portable path to file \'%0\'; specified path differs in case from file name on disk",
[c]="non-portable path to file \'A\'; specified path differs in case from file name on disk",
[d]=m,
[e]="non\\-portable path to file \'(.*?)\'; specified path differs in case from file name on disk",
[f]=" \\[(?:\\-Werror,)?\\-Wnonportable\\-include\\-path[^\\]]*\\]",
[h]=A,
[a]={"fc5d13d9b180",1464979971,"Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import p...","Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths.\n\nDifferential Revision: http://reviews.llvm.org/D19843\nCorresponding LLVM change: http://reviews.llvm.org/D19842\n\nPatch by Eric Niebler\n\nllvm-svn: 271708"},
[i]={{S,2487,"#endif\n // ...\n auto DiagId = (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) ? diag::pp_nonportable_path : diag::pp_nonportable_system_path;"}}
},
["pp_nonportable_system_path"]={
[j]={"nonportable-system-include-path"},
[k]="nonportable-system-include-path",
[g]="pp_nonportable_system_path",
[b]="non-portable path to file \'%0\'; specified path differs in case from file name on disk",
[c]="non-portable path to file \'A\'; specified path differs in case from file name on disk",
[d]=m,
[e]="non\\-portable path to file \'(.*?)\'; specified path differs in case from file name on disk",
[f]=" \\[(?:\\-Werror,)?\\-Wnonportable\\-system\\-include\\-path[^\\]]*\\]",
[h]=A,
[a]={"e8533670bf22",1465837398,"Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import p...","Use the name of the file on disk to issue a new diagnostic about non-portable #include and #import paths.\n\nDifferential Revision: http://reviews.llvm.org/D19843\nCorresponding LLVM change: http://reviews.llvm.org/D19842\n\nRe-commit after addressing issues with of generating too many warnings for Windows and asan test failures.\n\nPatch by Eric Niebler\n\nllvm-svn: 272562"},
[i]={{S,2488,"#endif\n // ...\n auto DiagId = (FileCharacter == SrcMgr::C_User || warnByDefaultOnWrongCase(Name)) ? diag::pp_nonportable_path : diag::pp_nonportable_system_path;"}}
},
["pp_out_of_date_dependency"]={
[g]="pp_out_of_date_dependency",
[b]="current file is older than dependency %0",
[c]="current file is older than dependency A",
[d]=m,
[e]="current file is older than dependency (.*?)",
[f]=jb,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{Jc,567,"/// HandlePragmaDependency - Handle \\#pragma GCC dependency \"foo\" blah.\nvoid Preprocessor::HandlePragmaDependency(Token &DependencyTok) {\n // ...\n // If this file is older than the file it depends on, emit a diagnostic.\n if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {\n // ...\n Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;"}}
},
["pp_poisoning_existing_macro"]={
[g]="pp_poisoning_existing_macro",
[b]="poisoning existing macro",
[c]="poisoning existing macro",
[d]=m,
[e]="poisoning existing macro",
[f]=jb,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{Jc,474,"/// HandlePragmaPoison - Handle \\#pragma GCC poison. PoisonTok is the \'poison\'.\nvoid Preprocessor::HandlePragmaPoison() {\n // ...\n while (true) {\n // ...\n // If this is a macro identifier, emit a warning.\n if (isMacroDefined(II))\n Diag(Tok, diag::pp_poisoning_existing_macro);"}}
},
["pp_pragma_once_in_main_file"]={
[j]={"pragma-once-outside-header"},
[k]="pragma-once-outside-header",
[g]="pp_pragma_once_in_main_file",
[b]="#pragma once in main file",
[c]="#pragma once in main file",
[d]=m,
[e]="\\#pragma once in main file",
[f]=" \\[(?:\\-Werror,)?\\-Wpragma\\-once\\-outside\\-header[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{Jc,424,"/// HandlePragmaOnce - Handle \\#pragma once. OnceTok is the \'once\'.\nvoid Preprocessor::HandlePragmaOnce(Token &OnceTok) {\n // Don\'t honor the \'once\' when handling the primary source file, unless\n // this is a prefix to a TU, which indicates we\'re generating a PCH file, or\n // when the main file is a header (e.g. when -xc-header is provided on the\n // commandline).\n if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {\n Diag(OnceTok, diag::pp_pragma_once_in_main_file);"}},
[l]={
["clang/test/Index/annotate-comments-preprocessor.c"]={"clang/test/Index/annotate-comments-preprocessor.c:32:9: warning: #pragma once in main file [-Wpragma-once-outside-header]"}
}
},
["pp_pragma_sysheader_in_main_file"]={
[j]={"pragma-system-header-outside-header"},
[k]="pragma-system-header-outside-header",
[g]="pp_pragma_sysheader_in_main_file",
[b]="#pragma system_header ignored in main file",
[c]="#pragma system_header ignored in main file",
[d]=m,
[e]="\\#pragma system_header ignored in main file",
[f]=" \\[(?:\\-Werror,)?\\-Wpragma\\-system\\-header\\-outside\\-header[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{Jc,487,"/// HandlePragmaSystemHeader - Implement \\#pragma GCC system_header. We know\n/// that the whole directive has been parsed.\nvoid Preprocessor::HandlePragmaSystemHeader(Token &SysHeaderTok) {\n if (isInPrimaryFile()) {\n Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);"}},
[l]={
["clang/test/Preprocessor/_Pragma.c"]={"clang/test/Preprocessor/_Pragma.c:3:1: warning: #pragma system_header ignored in main file [-Wpragma-system-header-outside-header]"}
}
},
["remark_cc1_round_trip_generated"]={
[j]={"round-trip-cc1-args"},
[k]="round-trip-cc1-args",
[g]={{nil,w,"remark_cc1_round_trip_generated"}},
[b]={{nil,z,"generated arguments #%0 in round-trip: %1"},{w,w,"Generated arguments #%0 in round-trip: %1"}},
[c]={{nil,z,"generated arguments #A in round-trip: B"},{w,w,"Generated arguments #A in round-trip: B"}},
[d]=U,
[e]="generated arguments \\#(.*?) in round\\-trip\\: (.*?)",
[f]=r,
[h]={{nil,w,O}},
[a]={"0175999805cf",1585492323,"[AMDGPU] Add options -mamdgpu-ieee -mno-amdgpu-ieee","[AMDGPU] Add options -mamdgpu-ieee -mno-amdgpu-ieee\n\nAMDGPU backend need to know whether floating point opcodes that support exception\nflag gathering quiet and propagate signaling NaN inputs per IEEE754-2008, which is\nconveyed by a function attribute \"amdgpu-ieee\". \"amdgpu-ieee\"=\"false\" turns this off.\nWithout this function attribute backend assumes it is on for compute functions.\n\n-mamdgpu-ieee and -mno-amdgpu-ieee are added to Clang to control this function attribute.\nBy default it is on. -mno-amdgpu-ieee requires -fno-honor-nans or equivalent.\n\nReviewed by: Matt Arsenault\n\nDifferential Revision: https://reviews.llvm.org/D77013"},
[i]={{"clang/lib/Frontend/CompilerInvocation.cpp",791,"#endif\n // ...\n Diags.Report(diag::remark_cc1_round_trip_generated) << 1 << SerializeArgs(GeneratedArgs);"},{"clang/lib/Frontend/CompilerInvocation.cpp",793,"#endif\n // ...\n Diags.Report(diag::remark_cc1_round_trip_generated) << 2 << SerializeArgs(ComparisonArgs);"},{"clang/tools/driver/cc1_main.cpp",211,"int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {\n // ...\n // Setup round-trip remarks for the DiagnosticsEngine used in CreateFromArgs.\n if (find(Argv, StringRef(\"-Rround-trip-cc1-args\")) != Argv.end())\n Diags.setSeverity(diag::remark_cc1_round_trip_generated, diag::Severity::Remark, {});"}},
[l]={
["clang/test/Frontend/round-trip-cc1-args.c"]={"remark: generated arguments #1 in round-trip: \"-cc1\" \"-Rround-trip-cc1-args\" \"-fsyntax-only\" \"-x\" \"c\" \"clang/test/Frontend/round-trip-cc1-args.c\" \"-triple\" \"x86_64-unknown-linux-gnu\" \"-nostdsysteminc\" \"-isystem\" \"build/lib/clang/17/include\" \"-std=gnu17\" \"-ffp-contract=off\" \"-fno-experimental-relative-c++-abi-vtables\" \"-fno-file-reproducible\" \"-O0\" \"-save-temps=obj\" \"-fdiagnostics-hotness-threshold=0\" \"-fdiagnostics-misexpect-tolerance=0\" ","remark: generated arguments #2 in round-trip: \"-cc1\" \"-Rround-trip-cc1-args\" \"-fsyntax-only\" \"-x\" \"c\" \"clang/test/Frontend/round-trip-cc1-args.c\" \"-triple\" \"x86_64-unknown-linux-gnu\" \"-nostdsysteminc\" \"-isystem\" \"build/lib/clang/17/include\" \"-std=gnu17\" \"-ffp-contract=off\" \"-fno-experimental-relative-c++-abi-vtables\" \"-fno-file-reproducible\" \"-O0\" \"-save-temps=obj\" \"-fdiagnostics-hotness-threshold=0\" \"-fdiagnostics-misexpect-tolerance=0\" "}
}
},
["remark_fe_backend_optimization_remark"]={
[j]={"pass"},
[k]="pass",
[g]="remark_fe_backend_optimization_remark",
[b]=Cc,
[c]=Sb,
[d]=U,
[e]=Ac,
[f]=" \\[[^\\]]*\\-Rpass[^\\]]*\\]",
[h]=nc,
[a]={"829b1700484d",1397667264,"Add support for optimization reports.","Add support for optimization reports.\n\nSummary:\nThis patch adds a new flag -Rpass=. The flag indicates the name\nof the optimization pass that should emit remarks stating when it\nmade a transformation to the code.\n\nThis implements the design I proposed in:\n\nhttps://docs.google.com/document/d/1FYUatSjZZO-zmFBxjOiuOzAy9mhHA8hqdvklZv68WuQ/edit?usp=sharing\n\nOther changes:\n- Add DiagnosticIDs::isRemark(). Use it in printDiagnosticOptions to\n print \"-R\" instead of \"-W\" in the diagnostic message.\n\n- In BackendConsumer::OptimizationRemarkHandler, get a SourceLocation\n object out of the file name, line and column number. Use that location\n in the call to Diags.Report().\n\n- When -Rpass is used without debug info a note is emitted alerting\n the user that they need to use -gline-tables-only -gcolumn-info to\n get this information.\n\nCC: llvm-commits\n\nDifferential Revision: http://llvm-reviews.chandlerc.com/D3226\n\nllvm-svn: 206401"},
[i]={{Mc,796,"void BackendConsumer::OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D) {\n // ...\n if (D.isPassed()) {\n // Optimization remarks are active only if the -Rpass flag has a regular\n // expression that matches the name of the pass name in \\p D.\n if (CodeGenOpts.OptimizationRemark.patternMatches(D.getPassName()))\n EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark);"}},
[l]={
["clang/test/CodeGenCUDA/atomics-remarks-gfx90a.cu"]={"clang/test/CodeGenCUDA/atomics-remarks-gfx90a.cu:15:10: remark: A compare and swap loop was generated for an atomic fadd operation at system memory scope [-Rpass=atomic-expand]"}
}
},
["remark_fe_backend_optimization_remark_analysis"]={
[j]={Yb},
[k]=Yb,
[g]="remark_fe_backend_optimization_remark_analysis",
[b]=Cc,
[c]=Sb,
[d]=U,
[e]=Ac,
[f]=" \\[[^\\]]*\\-Rpass\\-analysis[^\\]]*\\]",
[h]=nc,
[a]={"d23ec94393bf",1401393306,"Add flags -Rpass-missed and -Rpass-analysis.","Add flags -Rpass-missed and -Rpass-analysis.\n\nSummary:\nThese two flags are in the same family as -Rpass, but are used in\ndifferent situations.\n\n-Rpass-missed is used by optimizers to inform the user when they tried\nto apply an optimization but couldn\'t (or wouldn\'t).\n\n-Rpass-analysis is used by optimizers to report analysis results back\nto the user (e.g., why the transformation could not be applied).\n\nDepends on D3682.\n\nReviewers: rsmith\n\nSubscribers: cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D3683\n\nllvm-svn: 209839"},
[i]={{Mc,814,"void BackendConsumer::OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D) {\n // ...\n if (D.isPassed()) {\n // ...\n } else if (D.isMissed()) {\n // ...\n } else {\n // ...\n if (ShouldAlwaysPrint || CodeGenOpts.OptimizationRemarkAnalysis.patternMatches(D.getPassName()))\n EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark_analysis);"}}
},
["remark_fe_backend_optimization_remark_analysis_aliasing"]={
[j]={Yb},
[k]=Yb,
[g]="remark_fe_backend_optimization_remark_analysis_aliasing",
[b]="%0; allow reordering by specifying \'#pragma clang loop vectorize(enable)\' before the loop. If the arrays will always be independent specify \'#pragma clang loop vectorize(assume_safety)\' before the loop or provide the \'__restrict__\' qualifier with the independent array arguments. Erroneous results will occur if these options are incorrectly applied!",
[c]="A; allow reordering by specifying \'#pragma clang loop vectorize(enable)\' before the loop. If the arrays will always be independent specify \'#pragma clang loop vectorize(assume_safety)\' before the loop or provide the \'__restrict__\' qualifier with the independent array arguments. Erroneous results will occur if these options are incorrectly applied!",
[d]=U,
[e]="(.*?); allow reordering by specifying \'\\#pragma clang loop vectorize\\(enable\\)\' before the loop\\. If the arrays will always be independent specify \'\\#pragma clang loop vectorize\\(assume_safety\\)\' before the loop or provide the \'__restrict__\' qualifier with the independent array arguments\\. Erroneous results will occur if these options are incorrectly applied\\!",
[f]=" \\[[^\\]]*\\-Rpass\\-analysis[^\\]]*\\]",
[h]=nc,
[a]={"034baf615477",1439247916,"Append options for vectorization when pointer checking threshold is exceeded.","Append options for vectorization when pointer checking threshold is exceeded.\n\nFollowing one of the appended options will allow the loop to be vectorized. We do not include a command line option for modifying the pointer checking threshold because there is no clang-level interface for this currently.\n\nllvm-svn: 244526"},
[i]={{Mc,839,"void BackendConsumer::OptimizationRemarkHandler(const llvm::OptimizationRemarkAnalysisAliasing &D) {\n // ...\n if (D.shouldAlwaysPrint() || CodeGenOpts.OptimizationRemarkAnalysis.patternMatches(D.getPassName()))\n EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark_analysis_aliasing);"}},
[l]={
["clang/test/Frontend/optimization-remark-options.c"]={"clang/test/Frontend/optimization-remark-options.c:18:3: remark: loop not vectorized: cannot prove it is safe to reorder memory operations; allow reordering by specifying \'#pragma clang loop vectorize(enable)\' before the loop. If the arrays will always be independent specify \'#pragma clang loop vectorize(assume_safety)\' before the loop or provide the \'__restrict__\' qualifier with the independent array arguments. Erroneous results will occur if these options are incorrectly applied! [-Rpass-analysis=loop-vectorize]"}
}
},
["remark_fe_backend_optimization_remark_analysis_fpcommute"]={
[j]={Yb},
[k]=Yb,
[g]="remark_fe_backend_optimization_remark_analysis_fpcommute",
[b]="%0; allow reordering by specifying \'#pragma clang loop vectorize(enable)\' before the loop or by providing the compiler option \'-ffast-math\'.",
[c]="A; allow reordering by specifying \'#pragma clang loop vectorize(enable)\' before the loop or by providing the compiler option \'-ffast-math\'.",
[d]=U,
[e]="(.*?); allow reordering by specifying \'\\#pragma clang loop vectorize\\(enable\\)\' before the loop or by providing the compiler option \'\\-ffast\\-math\'\\.",
[f]=" \\[[^\\]]*\\-Rpass\\-analysis[^\\]]*\\]",
[h]=nc,
[a]={"8a0925cb627c",1439236600,"Append options for floating-point commutivity when related diagnostics are produced.","Append options for floating-point commutivity when related diagnostics are produced.\n\nWith this patch clang appends the command line options that would allow vectorization when floating-point commutativity is required. Specifically those are enabling fast-math or specifying a loop hint. \n\nllvm-svn: 244492"},
[i]={{Mc,827,"void BackendConsumer::OptimizationRemarkHandler(const llvm::OptimizationRemarkAnalysisFPCommute &D) {\n // ...\n if (D.shouldAlwaysPrint() || CodeGenOpts.OptimizationRemarkAnalysis.patternMatches(D.getPassName()))\n EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark_analysis_fpcommute);"}},
[l]={
["clang/test/Frontend/optimization-remark-options.c"]={"clang/test/Frontend/optimization-remark-options.c:10:11: remark: loop not vectorized: cannot prove it is safe to reorder floating-point operations; allow reordering by specifying \'#pragma clang loop vectorize(enable)\' before the loop or by providing the compiler option \'-ffast-math\'. [-Rpass-analysis=loop-vectorize]"}
}
},
["remark_fe_backend_optimization_remark_missed"]={
[j]={"pass-missed"},
[k]="pass-missed",
[g]="remark_fe_backend_optimization_remark_missed",
[b]=Cc,
[c]=Sb,
[d]=U,
[e]=Ac,
[f]=" \\[[^\\]]*\\-Rpass\\-missed[^\\]]*\\]",
[h]=nc,
[a]={"d23ec94393bf",1401393306,"Add flags -Rpass-missed and -Rpass-analysis.","Add flags -Rpass-missed and -Rpass-analysis.\n\nSummary:\nThese two flags are in the same family as -Rpass, but are used in\ndifferent situations.\n\n-Rpass-missed is used by optimizers to inform the user when they tried\nto apply an optimization but couldn\'t (or wouldn\'t).\n\n-Rpass-analysis is used by optimizers to report analysis results back\nto the user (e.g., why the transformation could not be applied).\n\nDepends on D3682.\n\nReviewers: rsmith\n\nSubscribers: cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D3683\n\nllvm-svn: 209839"},
[i]={{Mc,803,"void BackendConsumer::OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D) {\n // ...\n if (D.isPassed()) {\n // ...\n } else if (D.isMissed()) {\n // Missed optimization remarks are active only if the -Rpass-missed\n // flag has a regular expression that matches the name of the pass\n // name in \\p D.\n if (CodeGenOpts.OptimizationRemarkMissed.patternMatches(D.getPassName()))\n EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark_missed);"}}
},
["remark_fe_backend_plugin"]={
[j]={"remark-backend-plugin"},
[k]="remark-backend-plugin",
[g]="remark_fe_backend_plugin",
[b]=Cc,
[c]=Sb,
[d]=U,
[e]=Ac,
[f]=" \\[[^\\]]*\\-Rremark\\-backend\\-plugin[^\\]]*\\]",
[h]=nc,
[a]={"741602461d20",1393578668,"Add \'remark\' diagnostic type in \'clang\'","Add \'remark\' diagnostic type in \'clang\'\n\nA \'remark\' is information that is not an error or a warning, but rather some\nadditional information provided to the user. In contrast to a \'note\' a \'remark\'\nis an independent diagnostic, whereas a \'note\' always depends on another\ndiagnostic.\n\nA typical use case for remark nodes is information provided to the user, e.g.\ninformation provided by the vectorizer about loops that have been vectorized.\n\nThis patch provides the initial implementation of \'remarks\'. It includes the\nactual definiton of the remark nodes, their printing as well as basic parameter\nhandling. We are reusing the existing diagnostic parameters which means a remark\ncan be enabled with normal \'-Wdiagnostic-name\' flags and can be upgraded to\nan error using \'-Werror=diagnostic-name\'. \'-Werror\' alone does not upgrade\nremarks.\n\nThis patch is by intention minimal in terms of parameter handling. More\nexperience and more discussions will most likely lead to further enhancements\nin the parameter handling.\n\nllvm-svn: 202475"}
},
["remark_module_build"]={
[j]={Mb},
[k]=Mb,
[g]="remark_module_build",
[b]="building module \'%0\' as \'%1\'",
[c]="building module \'A\' as \'B\'",
[d]=U,
[e]="building module \'(.*?)\' as \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rmodule\\-build[^\\]]*\\]",
[h]=O,
[a]={"c95e56488d44",1399588562,"Switch Wmodule-build to a remark","Switch Wmodule-build to a remark\n\nOn reflection, this is better despite the missing command-line handling\nbits for remarks. Making this a remark makes it much clearer that\nthis is purely informational and avoids the negative connotations of a\n\'warning\'.\n\nllvm-svn: 208367"},
[i]={{Tc,1259,"/// Compile a module file for the given module, using the options\n/// provided by the importing compiler instance. Returns true if the module\n/// was built without errors.\nstatic bool compileModuleImpl(\n // ...\n ImportingInstance.getDiagnostics().Report(ImportLoc, diag::remark_module_build) << ModuleName << ModuleFileName;"}}
},
["remark_module_build_done"]={
[j]={Mb},
[k]=Mb,
[g]="remark_module_build_done",
[b]="finished building module \'%0\'",
[c]="finished building module \'A\'",
[d]=U,
[e]="finished building module \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rmodule\\-build[^\\]]*\\]",
[h]=O,
[a]={"99891da71a88",1413252510,"Extend -Rmodule-build to also remark when module building finishes.","Extend -Rmodule-build to also remark when module building finishes.\n\nIn cases of nested module builds, or when you care how long module builds take,\nthis information was not previously easily available / obvious.\n\nllvm-svn: 219658"},
[i]={{Tc,1276,"/// Compile a module file for the given module, using the options\n/// provided by the importing compiler instance. Returns true if the module\n/// was built without errors.\nstatic bool compileModuleImpl(\n // ...\n ImportingInstance.getDiagnostics().Report(ImportLoc, diag::remark_module_build_done) << ModuleName;"}}
},
["remark_module_import"]={
[j]={"module-import"},
[k]="module-import",
[g]={{nil,B,"remark_module_import"}},
[b]={{nil,B,"importing module \'%0\'%select{| into \'%3\'}2 from \'%1\'"}},
[c]={{nil,B,{"importing module \'A\'",{r," into \'D\'"}," from \'B\'"}}},
[d]=U,
[e]="importing module \'(.*?)\'(?:| into \'(.*?)\') from \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rmodule\\-import[^\\]]*\\]",
[h]={{nil,B,"AST Deserialization Issue"}},
[a]={"9dda8f540c8e",1551840646,"Modules: Add -Rmodule-import","Modules: Add -Rmodule-import\n\nAdd a remark for importing modules. Depending on whether this is a\ndirect import (into the TU being built by this compiler instance) or\ntransitive import (into an already-imported module), the diagnostic has\ntwo forms:\n\n importing module \'Foo\' from \'path/to/Foo.pcm\'\n importing module \'Foo\' into \'Bar\' from \'path/to/Foo.pcm\'\n\nAlso drop a redundant FileCheck invocation in Rmodule-build.m that was\nusing -Reverything, since the notes from -Rmodule-import were confusing\nit.\n\nhttps://reviews.llvm.org/D58891\n\nllvm-svn: 355477"},
[i]={{"clang/lib/Serialization/ASTReader.cpp",2975,"ASTReader::ASTReadResult ASTReader::ReadControlBlock(ModuleFile &F, SmallVectorImpl<ImportedModule> &Loaded, const ModuleFile *ImportedBy, unsigned ClientLoadCapabilities) {\n // ...\n while (true) {\n // ...\n case MODULE_NAME:\n // ...\n Diag(diag::remark_module_import) << F.ModuleName << F.FileName << (ImportedBy ? true : false) << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());"},{"clang/lib/Serialization/ASTReader.cpp",4592,"ASTReader::ASTReadResult ASTReader::ReadASTCore(StringRef FileName, ModuleKind Type, SourceLocation ImportLoc, ModuleFile *ImportedBy, SmallVectorImpl<ImportedModule> &Loaded, off_t ExpectedSize, time_t ExpectedModTime, ASTFileSignature ExpectedSignature, unsigned ClientLoadCapabilities) {\n // ...\n case ModuleManager::AlreadyLoaded:\n Diag(diag::remark_module_import) << M->ModuleName << M->FileName << (ImportedBy ? true : false) << (ImportedBy ? StringRef(ImportedBy->ModuleName) : StringRef());"}},
[l]={
["clang/test/Modules/Rmodule-import.m"]={"clang/test/Modules/Rmodule-import.m:16:2: remark: importing module \'A\' from \'/var/jenkins/workspace/llvm_stripf_diag_2/misc/llvm-warnings/llvmorg-17.0.6/build/tools/clang/test/Modules/Output/Rmodule-import.m.tmp2/A.pcm\' [-Rmodule-import]","clang/test/Modules/Rmodule-import.m:16:2: remark: importing module \'B\' into \'A\' from \'/var/jenkins/workspace/llvm_stripf_diag_2/misc/llvm-warnings/llvmorg-17.0.6/build/tools/clang/test/Modules/Output/Rmodule-import.m.tmp2/B.pcm\' [-Rmodule-import]","clang/test/Modules/Rmodule-import.m:16:2: remark: importing module \'C\' into \'B\' from \'/var/jenkins/workspace/llvm_stripf_diag_2/misc/llvm-warnings/llvmorg-17.0.6/build/tools/clang/test/Modules/Output/Rmodule-import.m.tmp2/C.pcm\' [-Rmodule-import]","clang/test/Modules/Rmodule-import.m:34:2: remark: importing module \'B\' from \'/var/jenkins/workspace/llvm_stripf_diag_2/misc/llvm-warnings/llvmorg-17.0.6/build/tools/clang/test/Modules/Output/Rmodule-import.m.tmp2/B.pcm\' [-Rmodule-import]","clang/test/Modules/Rmodule-import.m:37:2: remark: importing module \'C\' from \'/var/jenkins/workspace/llvm_stripf_diag_2/misc/llvm-warnings/llvmorg-17.0.6/build/tools/clang/test/Modules/Output/Rmodule-import.m.tmp2/C.pcm\' [-Rmodule-import]","clang/test/Modules/Rmodule-import.m:40:2: remark: importing module \'D\' from \'/var/jenkins/workspace/llvm_stripf_diag_2/misc/llvm-warnings/llvmorg-17.0.6/build/tools/clang/test/Modules/Output/Rmodule-import.m.tmp2/D.pcm\' [-Rmodule-import]"}
}
},
["remark_module_lock"]={
[j]={"module-lock"},
[k]="module-lock",
[g]={{nil,z,"remark_module_lock"}},
[b]={{nil,z,"locking \'%0\' to build module \'%1\'"}},
[c]={{nil,z,"locking \'A\' to build module \'B\'"}},
[d]=U,
[e]="locking \'(.*?)\' to build module \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rmodule\\-lock[^\\]]*\\]",
[h]={{nil,z,O}},
[a]={"b714f73defc8",1611802254,"Frontend: Add -f{,no-}implicit-modules-uses-lock and -Rmodule-lock","Frontend: Add -f{,no-}implicit-modules-uses-lock and -Rmodule-lock\n\nAdd -cc1 flags `-fmodules-uses-lock` and `-fno-modules-uses-lock` to\nallow the lock manager to be turned off when building implicit modules.\n\nAdd `-Rmodule-lock` so that we can see when it\'s being used.\n\nDifferential Revision: https://reviews.llvm.org/D95583"},
[i]={{Tc,1441,"/// Compile a module in a separate compiler instance and read the AST,\n/// returning true if the module compiles without errors, using a lock manager\n/// to avoid building the same module in multiple compiler instances.\n///\n/// Uses a lock file manager and exponential backoff to reduce the chances that\n/// multiple instances will compete to create the same module. On timeout,\n/// deletes the lock file in order to avoid deadlock from crashing processes or\n/// bugs in the lock file manager.\nstatic bool compileModuleAndReadASTBehindLock(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) {\n // ...\n Diags.Report(ModuleNameLoc, diag::remark_module_lock) << ModuleFileName << Module->Name;"}}
},
["remark_module_lock_failure"]={
[j]={Mb},
[k]=Mb,
[g]={{nil,E,"remark_module_lock_failure"}},
[b]={{nil,E,"could not acquire lock file for module \'%0\': %1"}},
[c]={{nil,E,"could not acquire lock file for module \'A\': B"}},
[d]=U,
[e]="could not acquire lock file for module \'(.*?)\'\\: (.*?)",
[f]=" \\[[^\\]]*\\-Rmodule\\-build[^\\]]*\\]",
[h]={{nil,E,db}},
[a]={"5a0af1fcd16e",1489796778,"[Modules] In case of lock timeout, fallback and build module","[Modules] In case of lock timeout, fallback and build module\n\nDuncan\'s r298165 introduced the PCMCache mechanism, which guarantees\nthat locks aren\'t necessary anymore for correctness but only for\nperformance, by avoiding building it twice when possible.\n\nChange the logic to avoid an error but actually build the module in case\nthe timeout happens. Instead of an error, still emit a remark for\ndebugging purposes.\n\nrdar://problem/30297862\n\nllvm-svn: 298175"},
[i]={{Tc,1456,"/// Compile a module in a separate compiler instance and read the AST,\n/// returning true if the module compiles without errors, using a lock manager\n/// to avoid building the same module in multiple compiler instances.\n///\n/// Uses a lock file manager and exponential backoff to reduce the chances that\n/// multiple instances will compete to create the same module. On timeout,\n/// deletes the lock file in order to avoid deadlock from crashing processes or\n/// bugs in the lock file manager.\nstatic bool compileModuleAndReadASTBehindLock(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) {\n // ...\n while (true) {\n // ...\n case llvm::LockFileManager::LFS_Error:\n // ...\n Diags.Report(ModuleNameLoc, diag::remark_module_lock_failure) << Module->Name << Locked.getErrorMessage();"}}
},
["remark_module_lock_timeout"]={
[j]={Mb},
[k]=Mb,
[g]={{nil,E,"remark_module_lock_timeout"}},
[b]={{nil,E,"timed out waiting to acquire lock file for module \'%0\'"}},
[c]={{nil,E,"timed out waiting to acquire lock file for module \'A\'"}},
[d]=U,
[e]="timed out waiting to acquire lock file for module \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rmodule\\-build[^\\]]*\\]",
[h]={{nil,E,db}},
[a]={"5a0af1fcd16e",1489796778,"[Modules] In case of lock timeout, fallback and build module","[Modules] In case of lock timeout, fallback and build module\n\nDuncan\'s r298165 introduced the PCMCache mechanism, which guarantees\nthat locks aren\'t necessary anymore for correctness but only for\nperformance, by avoiding building it twice when possible.\n\nChange the logic to avoid an error but actually build the module in case\nthe timeout happens. Instead of an error, still emit a remark for\ndebugging purposes.\n\nrdar://problem/30297862\n\nllvm-svn: 298175"},
[i]={{Tc,1481,"/// Compile a module in a separate compiler instance and read the AST,\n/// returning true if the module compiles without errors, using a lock manager\n/// to avoid building the same module in multiple compiler instances.\n///\n/// Uses a lock file manager and exponential backoff to reduce the chances that\n/// multiple instances will compete to create the same module. On timeout,\n/// deletes the lock file in order to avoid deadlock from crashing processes or\n/// bugs in the lock file manager.\nstatic bool compileModuleAndReadASTBehindLock(CompilerInstance &ImportingInstance, SourceLocation ImportLoc, SourceLocation ModuleNameLoc, Module *Module, StringRef ModuleFileName) {\n // ...\n while (true) {\n // ...\n case llvm::LockFileManager::Res_Timeout:\n // ...\n Diags.Report(ModuleNameLoc, diag::remark_module_lock_timeout) << Module->Name;"}}
},
["remark_pp_include_directive_modular_translation"]={
[j]={"module-include-translation"},
[k]="module-include-translation",
[g]={{nil,D,"remark_pp_include_directive_modular_translation"}},
[b]={{nil,D,"treating #%select{include|import|include_next|__include_macros}0 as an import of module \'%1\'"}},
[c]={{nil,D,{"treating #",{"include","import","include_next","__include_macros"}," as an import of module \'B\'"}}},
[d]=U,
[e]="treating \\#(?:include|import|include_next|__include_macros) as an import of module \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rmodule\\-include\\-translation[^\\]]*\\]",
[h]={{nil,D,A}},
[a]={sb,1625925174,rb,vb},
[i]={{S,1858,"/// Produce a diagnostic informing the user that a #include or similar\n/// was implicitly treated as a module import.\nstatic void diagnoseAutoModuleImport(Preprocessor &PP, SourceLocation HashLoc, Token &IncludeTok, ArrayRef<std::pair<IdentifierInfo *, SourceLocation>> Path, SourceLocation PathEnd) {\n // ...\n PP.Diag(HashLoc, diag::remark_pp_include_directive_modular_translation) << IncludeKind << PathString;"}},
[l]={
["clang/test/Modules/subframeworks.m"]={"clang/test/Modules/Inputs/HasSubModules.framework/Frameworks/Sub.framework/PrivateHeaders/SubPriv.h:1:1: remark: treating #include as an import of module \'HasSubModules.Sub.Types\' [-Rmodule-include-translation]"}
}
},
["remark_pp_search_path_usage"]={
[j]={"search-path-usage"},
[k]="search-path-usage",
[g]={{nil,z,"remark_pp_search_path_usage"}},
[b]={{nil,z,"search path used: \'%0\'"}},
[c]={{nil,z,"search path used: \'A\'"}},
[d]=U,
[e]="search path used\\: \'(.*?)\'",
[f]=" \\[[^\\]]*\\-Rsearch\\-path\\-usage[^\\]]*\\]",
[h]={{nil,z,A}},
[a]={sb,1625925174,rb,vb},
[i]={{"clang/lib/Lex/HeaderSearch.cpp",744,"void HeaderSearch::noteLookupUsage(unsigned HitIdx, SourceLocation Loc) {\n // ...\n if (UserEntryIdxIt != SearchDirToHSEntry.end())\n Diags.Report(Loc, diag::remark_pp_search_path_usage) << HSOpts->UserEntries[UserEntryIdxIt->second].Path;"}},
[l]={
["clang/test/Preprocessor/search-path-usage.m"]={"clang/test/Preprocessor/search-path-usage.m:127:19: remark: search path used: \'build/tools/clang/test/Preprocessor/Output/search-path-usage.m.tmp/b-missing.hmap\' [-Rsearch-path-usage]"}
}
},
["remark_sanitize_address_insert_extra_padding_accepted"]={
[j]={"sanitize-address"},
[k]="sanitize-address",
[g]="remark_sanitize_address_insert_extra_padding_accepted",
[b]="-fsanitize-address-field-padding applied to %0",
[c]="-fsanitize-address-field-padding applied to A",
[d]=U,
[e]="\\-fsanitize\\-address\\-field\\-padding applied to (.*?)",
[f]=" \\[[^\\]]*\\-Rsanitize\\-address[^\\]]*\\]",
[h]=O,
[a]={"293dc9be6e36",1413492892,"Insert poisoned paddings between fields in C++ classes so that AddressSanitizer can find intra-objec...","Insert poisoned paddings between fields in C++ classes so that AddressSanitizer can find intra-object-overflow bugs\n\nSummary:\nThe general approach is to add extra paddings after every field\nin AST/RecordLayoutBuilder.cpp, then add code to CTORs/DTORs that poisons the paddings\n(CodeGen/CGClass.cpp).\n\nEverything is done under the flag -fsanitize-address-field-padding. \nThe blacklist file (-fsanitize-blacklist) allows to avoid the transformation \nfor given classes or source files. \n\nSee also https://code.google.com/p/address-sanitizer/wiki/IntraObjectOverflow\n\nTest Plan: run SPEC2006 and some of the Chromium tests with -fsanitize-address-field-padding\n\nReviewers: samsonov, rnk, rsmith\n\nReviewed By: rsmith\n\nSubscribers: majnemer, cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D5687\n\nllvm-svn: 219961"},
[i]={{"clang/lib/AST/Decl.cpp",5004,"bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {\n // ...\n if (EmitRemark) {\n if (ReasonToReject >= 0)\n // ...\n else\n Context.getDiagnostics().Report(getLocation(), diag::remark_sanitize_address_insert_extra_padding_accepted) << getQualifiedNameAsString();"}},
[l]={
["clang/test/CodeGen/sanitize-address-field-padding.cpp"]={"clang/test/CodeGen/sanitize-address-field-padding.cpp:28:7: remark: -fsanitize-address-field-padding applied to Positive1 [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:48:7: remark: -fsanitize-address-field-padding applied to ClassWithVirtualBase [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:60:7: remark: -fsanitize-address-field-padding applied to WithFlexibleArray1 [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:73:7: remark: -fsanitize-address-field-padding applied to WithFlexibleArray2 [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:82:7: remark: -fsanitize-address-field-padding applied to WithFlexibleArray3 [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:199:8: remark: -fsanitize-address-field-padding applied to WithVirtualDtor [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:203:8: remark: -fsanitize-address-field-padding applied to InheritsFrom_WithVirtualDtor [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:224:8: remark: -fsanitize-address-field-padding applied to ClassWithTrivialCopy [-Rsanitize-address]"}
}
},
["remark_sanitize_address_insert_extra_padding_rejected"]={
[j]={"sanitize-address"},
[k]="sanitize-address",
[g]="remark_sanitize_address_insert_extra_padding_rejected",
[b]={{nil,z,"-fsanitize-address-field-padding ignored for %0 because it %select{is not C++|is packed|is a union|is trivially copyable|has trivial destructor|is standard layout|is in a ignorelisted file|is ignorelisted}1"},{w,nil,"-fsanitize-address-field-padding ignored for %0 because it %select{is not C++|is packed|is a union|is trivially copyable|has trivial destructor|is standard layout|is in a blacklisted file|is blacklisted}1"}},
[c]={{nil,z,{"-fsanitize-address-field-padding ignored for A because it ",{"is not C++","is packed","is a union","is trivially copyable","has trivial destructor","is standard layout","is in a ignorelisted file","is ignorelisted"}}},{w,nil,{"-fsanitize-address-field-padding ignored for A because it ",{"is not C++","is packed","is a union","is trivially copyable","has trivial destructor","is standard layout","is in a blacklisted file","is blacklisted"}}}},
[d]=U,
[e]="\\-fsanitize\\-address\\-field\\-padding ignored for (.*?) because it (?:is not C\\+\\+|is packed|is a union|is trivially copyable|has trivial destructor|is standard layout|is in a ignorelisted file|is ignorelisted)",
[f]=" \\[[^\\]]*\\-Rsanitize\\-address[^\\]]*\\]",
[h]=O,
[a]={"293dc9be6e36",1413492892,"Insert poisoned paddings between fields in C++ classes so that AddressSanitizer can find intra-objec...","Insert poisoned paddings between fields in C++ classes so that AddressSanitizer can find intra-object-overflow bugs\n\nSummary:\nThe general approach is to add extra paddings after every field\nin AST/RecordLayoutBuilder.cpp, then add code to CTORs/DTORs that poisons the paddings\n(CodeGen/CGClass.cpp).\n\nEverything is done under the flag -fsanitize-address-field-padding. \nThe blacklist file (-fsanitize-blacklist) allows to avoid the transformation \nfor given classes or source files. \n\nSee also https://code.google.com/p/address-sanitizer/wiki/IntraObjectOverflow\n\nTest Plan: run SPEC2006 and some of the Chromium tests with -fsanitize-address-field-padding\n\nReviewers: samsonov, rnk, rsmith\n\nReviewed By: rsmith\n\nSubscribers: majnemer, cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D5687\n\nllvm-svn: 219961"},
[i]={{"clang/lib/AST/Decl.cpp",4999,"bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {\n // ...\n if (EmitRemark) {\n if (ReasonToReject >= 0)\n Context.getDiagnostics().Report(getLocation(), diag::remark_sanitize_address_insert_extra_padding_rejected) << getQualifiedNameAsString() << ReasonToReject;"}},
[l]={
["clang/test/CodeGen/sanitize-address-field-padding.cpp"]={"clang/test/CodeGen/sanitize-address-field-padding.cpp:28:7: remark: -fsanitize-address-field-padding ignored for Positive1 because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:44:8: remark: -fsanitize-address-field-padding ignored for VirtualBase because it is trivially copyable [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:48:7: remark: -fsanitize-address-field-padding ignored for ClassWithVirtualBase because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:60:7: remark: -fsanitize-address-field-padding ignored for WithFlexibleArray1 because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:73:7: remark: -fsanitize-address-field-padding ignored for WithFlexibleArray2 because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:82:7: remark: -fsanitize-address-field-padding ignored for WithFlexibleArray3 because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:91:7: remark: -fsanitize-address-field-padding ignored for Negative1 because it is trivially copyable [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:99:7: remark: -fsanitize-address-field-padding ignored for Negative2 because it is trivially copyable [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:108:7: remark: -fsanitize-address-field-padding ignored for Negative3 because it is a union [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:116:7: remark: -fsanitize-address-field-padding ignored for Negative4 because it is trivially copyable [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:129:31: remark: -fsanitize-address-field-padding ignored for Negative5 because it is packed [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:144:7: remark: -fsanitize-address-field-padding ignored for SomeNamespace::IgnorelistedByName because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:158:7: remark: -fsanitize-address-field-padding ignored for ExternCStruct because it is not C++ [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:199:8: remark: -fsanitize-address-field-padding ignored for WithVirtualDtor because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:203:8: remark: -fsanitize-address-field-padding ignored for InheritsFrom_WithVirtualDtor because it is in a ignorelisted file [-Rsanitize-address]","clang/test/CodeGen/sanitize-address-field-padding.cpp:224:8: remark: -fsanitize-address-field-padding ignored for ClassWithTrivialCopy because it is in a ignorelisted file [-Rsanitize-address]"}
}
},
["remark_sloc_usage"]={
[j]={"sloc-usage"},
[k]="sloc-usage",
[g]={{nil,v,"remark_sloc_usage"}},
[b]={{nil,v,"source manager location address space usage:"}},
[c]={{nil,v,"source manager location address space usage:"}},
[d]=U,
[e]="source manager location address space usage\\:",
[f]=" \\[[^\\]]*\\-Rsloc\\-usage[^\\]]*\\]",
[h]={{nil,v,O}},
[a]={"9e52db182794",1668037554,"When we run out of source locations, try to produce useful information","When we run out of source locations, try to produce useful information\nindicating why we ran out."},
[i]={{Jc,1202,"struct PragmaDebugHandler : public PragmaHandler {\n // ...\n void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &DebugToken) override {\n // ...\n if (II->isStr(\"assert\")) {\n // ...\n } else if (II->isStr(\"crash\")) {\n // ...\n } else if (II->isStr(\"parser_crash\")) {\n // ...\n } else if (II->isStr(\"dump\")) {\n // ...\n } else if (II->isStr(\"diag_mapping\")) {\n // ...\n } else if (II->isStr(\"llvm_fatal_error\")) {\n // ...\n } else if (II->isStr(\"llvm_unreachable\")) {\n // ...\n } else if (II->isStr(\"macro\")) {\n // ...\n } else if (II->isStr(\"module_map\")) {\n // ...\n } else if (II->isStr(\"overflow_stack\")) {\n // ...\n } else if (II->isStr(\"captured\")) {\n // ...\n } else if (II->isStr(\"modules\")) {\n // ...\n } else if (II->isStr(\"sloc_usage\")) {\n // ...\n PP.Diag(Tok, diag::remark_sloc_usage);"},{"clang/lib/Serialization/ASTReader.cpp",3487,"llvm::Error ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {\n // ...\n while (true) {\n // ...\n case SOURCE_LOCATION_OFFSETS: {\n // ...\n if (!F.SLocEntryBaseID) {\n if (!Diags.isDiagnosticInFlight()) {\n Diags.Report(SourceLocation(), diag::remark_sloc_usage);"}},
[l]={
["clang/test/Misc/sloc-usage.cpp"]={"clang/test/Misc/sloc-usage.cpp:10:23: remark: source manager location address space usage: [-Rsloc-usage]"}
}
},
["trigraph_converted"]={
[j]={P,T,cb,Jb},
[k]=Jb,
[g]="trigraph_converted",
[b]="trigraph converted to \'%0\' character",
[c]="trigraph converted to \'A\' character",
[d]=m,
[e]="trigraph converted to \'(.*?)\' character",
[f]=" \\[(?:\\-Werror,)?\\-Wtrigraphs[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{bb,1210,"/// DecodeTrigraphChar - If the specified character is a legal trigraph when\n/// prefixed with ??, emit a trigraph warning. If trigraphs are enabled,\n/// return the result character. Finally, emit a warning about trigraph use\n/// whether trigraphs are enabled or not.\nstatic char DecodeTrigraphChar(const char *CP, Lexer *L, bool Trigraphs) {\n // ...\n if (L && !L->isLexingRawMode())\n L->Diag(CP - 2, diag::trigraph_converted) << StringRef(&Res, 1);"}},
[l]={
["clang/test/Lexer/constants.c"]={"clang/test/Lexer/constants.c:28:4: warning: trigraph converted to \'|\' character [-Wtrigraphs]"}
}
},
["trigraph_ends_block_comment"]={
[j]={P,T,cb,Jb},
[k]=Jb,
[g]="trigraph_ends_block_comment",
[b]="trigraph ends block comment",
[c]="trigraph ends block comment",
[d]=m,
[e]="trigraph ends block comment",
[f]=" \\[(?:\\-Werror,)?\\-Wtrigraphs[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{bb,2690,"/// isBlockCommentEndOfEscapedNewLine - Return true if the specified newline\n/// character (either \\\\n or \\\\r) is part of an escaped newline sequence. Issue\n/// a diagnostic if so. We know that the newline is inside of a block comment.\nstatic bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr, Lexer *L, bool Trigraphs) {\n // ...\n if (TrigraphPos) {\n // ...\n if (!L->isLexingRawMode())\n L->Diag(TrigraphPos, diag::trigraph_ends_block_comment);"}},
[l]={
["clang/test/Lexer/block_cmt_end.c"]={"clang/test/Lexer/block_cmt_end.c:26:168: warning: trigraph ends block comment [-Wtrigraphs]","clang/test/Lexer/block_cmt_end.c:39:1: warning: trigraph ends block comment [-Wtrigraphs]"}
}
},
["trigraph_ignored"]={
[j]={P,T,cb,Jb},
[k]=Jb,
[g]="trigraph_ignored",
[b]="trigraph ignored",
[c]="trigraph ignored",
[d]=m,
[e]="trigraph ignored",
[f]=" \\[(?:\\-Werror,)?\\-Wtrigraphs[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{bb,1205,"/// DecodeTrigraphChar - If the specified character is a legal trigraph when\n/// prefixed with ??, emit a trigraph warning. If trigraphs are enabled,\n/// return the result character. Finally, emit a warning about trigraph use\n/// whether trigraphs are enabled or not.\nstatic char DecodeTrigraphChar(const char *CP, Lexer *L, bool Trigraphs) {\n // ...\n if (!Trigraphs) {\n if (L && !L->isLexingRawMode())\n L->Diag(CP - 2, diag::trigraph_ignored);"}},
[l]={
["clang/test/SemaCXX/cxx2a-nttp-printing.cpp"]={"clang/test/SemaCXX/cxx2a-nttp-printing.cpp:31:14: warning: trigraph ignored [-Wtrigraphs]"}
}
},
["trigraph_ignored_block_comment"]={
[j]={P,T,cb,Jb},
[k]=Jb,
[g]="trigraph_ignored_block_comment",
[b]="ignored trigraph would end block comment",
[c]="ignored trigraph would end block comment",
[d]=m,
[e]="ignored trigraph would end block comment",
[f]=" \\[(?:\\-Werror,)?\\-Wtrigraphs[^\\]]*\\]",
[h]=A,
[a]={K,1236199783,J,I},
[i]={{bb,2686,"/// isBlockCommentEndOfEscapedNewLine - Return true if the specified newline\n/// character (either \\\\n or \\\\r) is part of an escaped newline sequence. Issue\n/// a diagnostic if so. We know that the newline is inside of a block comment.\nstatic bool isEndOfBlockCommentWithEscapedNewLine(const char *CurPtr, Lexer *L, bool Trigraphs) {\n // ...\n if (TrigraphPos) {\n // If no trigraphs are enabled, warn that we ignored this trigraph and\n // ignore this * character.\n if (!Trigraphs) {\n if (!L->isLexingRawMode())\n L->Diag(TrigraphPos, diag::trigraph_ignored_block_comment);"}}
},
["warn_O4_is_O3"]={
[j]={eb},
[k]=eb,
[g]="warn_O4_is_O3",
[b]="-O4 is equivalent to -O3",
[c]="-O4 is equivalent to -O3",
[d]=m,
[e]="\\-O4 is equivalent to \\-O3",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated[^\\]]*\\]",
[h]=Gb,
[a]={"ad70d9683ea7",1377622695,"Warn that -O4 is the same as -O3.","Warn that -O4 is the same as -O3.\n\nWe error on -O5 and higher. While it is tempting to do the same for -O4, I\nagree with Jordan Rose: we should warn for a release at least first.\n\nllvm-svn: 189369"},
[i]={{"clang/lib/Driver/ToolChains/Clang.cpp",5075,"void Clang::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const {\n // ...\n // Embed-bitcode option.\n // Only white-listed flags below are allowed to be embedded.\n if (C.getDriver().embedBitcodeInObject() && !IsUsingLTO && (isa<BackendJobAction>(JA) || isa<AssembleJobAction>(JA))) {\n // ...\n // Optimization level for CodeGen.\n if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {\n if (A->getOption().matches(options::OPT_O4)) {\n // ...\n D.Diag(diag::warn_O4_is_O3);"},{"clang/lib/Driver/ToolChains/Clang.cpp",5932,"#endif\n // ...\n // Manually translate -O4 to -O3; let clang reject others.\n if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {\n if (A->getOption().matches(options::OPT_O4)) {\n // ...\n D.Diag(diag::warn_O4_is_O3);"},{"clang/lib/Driver/ToolChains/Flang.cpp",507,"void Flang::ConstructJob(Compilation &C, const JobAction &JA, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const char *LinkingOutput) const {\n // ...\n // Optimization level for CodeGen.\n if (const Arg *A = Args.getLastArg(options::OPT_O_Group)) {\n if (A->getOption().matches(options::OPT_O4)) {\n // ...\n D.Diag(diag::warn_O4_is_O3);"}}
},
["warn_abs_too_small"]={
[j]={"absolute-value"},
[k]="absolute-value",
[g]="warn_abs_too_small",
[b]="absolute value function %0 given an argument of type %1 but has parameter of type %2 which may cause truncation of value",
[c]="absolute value function A given an argument of type B but has parameter of type C which may cause truncation of value",
[d]=m,
[e]="absolute value function (.*?) given an argument of type (.*?) but has parameter of type (.*?) which may cause truncation of value",
[f]=" \\[(?:\\-Werror,)?\\-Wabsolute\\-value[^\\]]*\\]",
[h]=n,
[a]={"7eb0b2c1819c",1393377448,"Add -Wabsolute-value, warnings about absolute value functions.","Add -Wabsolute-value, warnings about absolute value functions.\n\nThe warnings fall into three groups.\n1) Using an absolute value function of the wrong type, for instance, using the\nint absolute value function when the argument is a floating point type.\n2) Using the improper sized absolute value function, for instance, using abs\nwhen the argument is a long long. llabs should be used instead.\n\nFrom these two cases, an implicit conversion will occur which may cause\nunexpected behavior. Where possible, suggest the proper absolute value\nfunction to use, and which header to include if the function is not available.\n\n3) Taking the absolute value of an unsigned value. In addition to this warning,\nsuggest to remove the function call. This usually indicates a logic error\nsince the programmer assumed negative values would have been possible.\n\nllvm-svn: 202211"},
[i]={{u,12060,"// Warn when using the wrong abs() function.\nvoid Sema::CheckAbsoluteValueFunction(const CallExpr *Call, const FunctionDecl *FDecl) {\n // ...\n // The argument and parameter are the same kind. Check if they are the right\n // size.\n if (ArgValueKind == ParamValueKind) {\n // ...\n Diag(Call->getExprLoc(), diag::warn_abs_too_small) << FDecl << ArgType << ParamType;"},{"clang/utils/TableGen/ClangDiagnosticsEmitter.cpp",1409,"/// /* DiagArray2 */ diag::warn_abs_too_small,"}},
[l]={
["clang/test/Sema/warn-absolute-value-header.c"]={"clang/test/Sema/warn-absolute-value-header.c:23:9: warning: absolute value function \'abs\' given an argument of type \'long long\' but has parameter of type \'int\' which may cause truncation of value [-Wabsolute-value]"}
}
},
["warn_abstract_final_class"]={
[j]={"abstract-final-class"},
[k]="abstract-final-class",
[g]="warn_abstract_final_class",
[b]="abstract class is marked \'%select{final|sealed}0\'",
[c]={{nil,nil,{"abstract class is marked \'",{"final","sealed"},"\'"}}},
[d]=m,
[e]="abstract class is marked \'(?:final|sealed)\'",
[f]=" \\[(?:\\-Werror,)?\\-Wabstract\\-final\\-class[^\\]]*\\]",
[h]=n,
[a]={"348df509a0b7",1348197667,"PR13890: Warn on abstract final classes.","PR13890: Warn on abstract final classes.\n\nllvm-svn: 164359"},
[i]={{C,6974,"/// Perform semantic checks on a class definition that has been\n/// completing, introducing implicitly-declared members, checking for\n/// abstract types, etc.\n///\n/// \\param S The scope in which the class was parsed. Null if we didn\'t just\n/// parse a class definition.\n/// \\param Record The completed class.\nvoid Sema::CheckCompletedCXXClass(Scope *S, CXXRecordDecl *Record) {\n // ...\n if (Record->isAbstract()) {\n if (FinalAttr *FA = Record->getAttr<FinalAttr>()) {\n Diag(Record->getLocation(), diag::warn_abstract_final_class) << FA->isSpelledAsSealed();"}},
[l]={
["clang/test/CXX/class/p2-0x.cpp"]={"clang/test/CXX/class/p2-0x.cpp:31:8: warning: abstract class is marked \'final\' [-Wabstract-final-class]","clang/test/CXX/class/p2-0x.cpp:34:8: warning: abstract class is marked \'final\' [-Wabstract-final-class]"}
}
},
["warn_abstract_vbase_init_ignored"]={
[j]={"abstract-vbase-init"},
[k]="abstract-vbase-init",
[g]="warn_abstract_vbase_init_ignored",
[b]="initializer for virtual base class %0 of abstract class %1 will never be used",
[c]="initializer for virtual base class A of abstract class B will never be used",
[d]=m,
[e]="initializer for virtual base class (.*?) of abstract class (.*?) will never be used",
[f]=" \\[(?:\\-Werror,)?\\-Wabstract\\-vbase\\-init[^\\]]*\\]",
[h]=n,
[a]={"bc46e4341e95",1374461816,"Implement DR257 / fix PR16659:","Implement DR257 / fix PR16659:\n A constructor for an abstract class does not call constructors for virtual\n base classes, so it is not an error if no initializer is present for the\n virtual base and the virtual base cannot be default initialized.\n\nAlso provide a (disabled by default, for now) warning for the case where a\nvirtual base class\'s initializer is ignored in an abstract class\'s constructor,\nand address a defect in DR257 where it was not carried through to C++11\'s rules\nfor implicit deletion of special member functions.\n\nBased on a patch by Maurice Bos.\n\nllvm-svn: 186803"},
[i]={{C,5351,"bool Sema::SetCtorInitializers(CXXConstructorDecl *Constructor, bool AnyErrors, ArrayRef<CXXCtorInitializer *> Initializers) {\n // ...\n // Push virtual bases before others.\n for (auto &VBase : ClassDecl->vbases()) {\n if (CXXCtorInitializer *Value = Info.AllBaseFields.lookup(VBase.getType()->getAs<RecordType>())) {\n // [class.base.init]p7, per DR257:\n // A mem-initializer where the mem-initializer-id names a virtual base\n // class is ignored during execution of a constructor of any class that\n // is not the most derived class.\n if (ClassDecl->isAbstract()) {\n // ...\n Diag(Value->getSourceLocation(), diag::warn_abstract_vbase_init_ignored) << VBase.getType() << ClassDecl;"}},
[l]={
["clang/test/SemaCXX/abstract.cpp"]={"clang/test/SemaCXX/abstract.cpp:318:23: warning: initializer for virtual base class \'A\' of abstract class \'RedundantInit\' will never be used [-Wabstract-vbase-init]"}
}
},
["warn_access_decl_deprecated"]={
[j]={eb},
[k]=eb,
[g]="warn_access_decl_deprecated",
[b]="access declarations are deprecated; use using declarations instead",
[c]="access declarations are deprecated; use using declarations instead",
[d]=m,
[e]="access declarations are deprecated; use using declarations instead",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated[^\\]]*\\]",
[h]=Gb,
[a]={"a009726ce3a0",1260497403,"Implement access declarations. Most of the work here is parsing them, which","Implement access declarations. Most of the work here is parsing them, which\nis difficult because they\'re so terribly, terribly ambiguous.\n\n\nWe implement access declarations in terms of using declarations, which is\nquite reasonable. However, we should really persist the access/using\ndistinction in the AST and use the appropriate name in diagnostics. This\nisn\'t a priority, so I\'ll just file a PR and hope someone else does it. :)\n\nllvm-svn: 91095"},
[i]={{C,12069,"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 \");"}},
[l]={
["clang/test/CXX/class.access/class.access.dcl/p1.cpp"]={"clang/test/CXX/class.access/class.access.dcl/p1.cpp:29:15: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:36:15: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:43:15: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:50:15: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:71:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:77:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:84:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:91:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:98:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:142:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:149:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:156:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:163:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:170:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:216:11: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:223:11: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:230:11: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:237:11: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:244:11: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:300:14: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:307:11: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:314:16: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:321:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:329:15: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]","clang/test/CXX/class.access/class.access.dcl/p1.cpp:341:8: warning: access declarations are deprecated; use using declarations instead [-Wdeprecated]"}
}
},
["warn_accessor_property_type_mismatch"]={
[g]="warn_accessor_property_type_mismatch",
[b]="type of property %0 does not match type of accessor %1",
[c]="type of property A does not match type of accessor B",
[d]=m,
[e]="type of property (.*?) does not match type of accessor (.*?)",
[f]=jb,
[h]=n,
[a]={"b2ab73d93cf5",1241811394,"More type checking for properties, accessors and","More type checking for properties, accessors and\nuse of dot-syntax expression. This is to match gcc\'s.\n\nllvm-svn: 71243"},
[i]={{pb,1742,"bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property, ObjCMethodDecl *GetterMethod, SourceLocation Loc) {\n // ...\n if (!compat) {\n Diag(Loc, diag::warn_accessor_property_type_mismatch) << property->getDeclName() << GetterMethod->getSelector();"},{pb,2452,"/// ProcessPropertyDecl - Make sure that any user-defined setter/getter methods\n/// have the property type and issue diagnostics if they don\'t.\n/// Also synthesize a getter/setter method if none exist (and update the\n/// appropriate lookup tables.\nvoid Sema::ProcessPropertyDecl(ObjCPropertyDecl *property) {\n // ...\n if (!property->isReadOnly() && SetterMethod) {\n // ...\n if (SetterMethod->param_size() != 1 || !Context.hasSameUnqualifiedType((*SetterMethod->param_begin())->getType().getNonReferenceType(), property->getType().getNonReferenceType())) {\n Diag(property->getLocation(), diag::warn_accessor_property_type_mismatch) << property->getDeclName() << SetterMethod->getSelector();"}},
[l]={
["clang/test/SemaObjC/property-impl-misuse.m"]={"clang/test/SemaObjC/property-impl-misuse.m:43:15: warning: type of property \'P1\' does not match type of accessor \'P1\'"}
}
},
["warn_acquire_requires_negative_cap"]={
[j]={"thread-safety-negative"},
[k]="thread-safety-negative",
[g]="warn_acquire_requires_negative_cap",
[b]="acquiring %0 \'%1\' requires negative capability \'%2\'",
[c]="acquiring A \'B\' requires negative capability \'C\'",
[d]=m,
[e]="acquiring (.*?) \'(.*?)\' requires negative capability \'(.*?)\'",
[f]=" \\[(?:\\-Werror,)?\\-Wthread\\-safety\\-negative[^\\]]*\\]",
[h]=n,
[a]={"3efd0495a081",1407190386,"Thread Safety Analysis: add a -Wthread-safety-negative flag that warns whenever","Thread Safety Analysis: add a -Wthread-safety-negative flag that warns whenever\na mutex is acquired, but corresponding mutex is not provably not-held. This\nis based on the earlier negative requirements patch.\n\nllvm-svn: 214789"},
[i]={{M,2021,"class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {\n // ...\n void handleNegativeNotHeld(StringRef Kind, Name LockName, Name Neg, SourceLocation Loc) override {\n PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_acquire_requires_negative_cap) << Kind << LockName << Neg);"}},
[l]={
["clang/test/SemaCXX/warn-thread-safety-negative.cpp"]={"clang/test/SemaCXX/warn-thread-safety-negative.cpp:52:8: warning: acquiring mutex \'mu\' requires negative capability \'!mu\' [-Wthread-safety-negative]","clang/test/SemaCXX/warn-thread-safety-negative.cpp:74:8: warning: acquiring mutex \'mu\' requires negative capability \'!mu\' [-Wthread-safety-negative]","clang/test/SemaCXX/warn-thread-safety-negative.cpp:88:15: warning: acquiring mutex \'mu\' requires negative capability \'!mu\' [-Wthread-safety-negative]"}
}
},
["warn_acquired_before"]={
[j]={"thread-safety",Zb},
[k]=Zb,
[g]="warn_acquired_before",
[b]="%0 \'%1\' must be acquired before \'%2\'",
[c]="A \'B\' must be acquired before \'C\'",
[d]=m,
[e]="(.*?) \'(.*?)\' must be acquired before \'(.*?)\'",
[f]=" \\[(?:\\-Werror,)?\\-Wthread\\-safety\\-analysis[^\\]]*\\]",
[h]=n,
[a]={"4980df623f15",1422987468,"Thread Safety Analysis: add support for before/after annotations on mutexes.","Thread Safety Analysis: add support for before/after annotations on mutexes.\nThese checks detect potential deadlocks caused by inconsistent lock\nordering. The checks are implemented under the -Wthread-safety-beta flag.\n\nllvm-svn: 227997"},
[i]={{M,2043,"class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {\n // ...\n void handleLockAcquiredBefore(StringRef Kind, Name L1Name, Name L2Name, SourceLocation Loc) override {\n PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_acquired_before) << Kind << L1Name << L2Name);"}},
[l]={
["clang/test/Sema/warn-thread-safety-analysis.c"]={"clang/test/Sema/warn-thread-safety-analysis.c:84:3: warning: mutex \'mu1\' must be acquired before \'mu2\' [-Wthread-safety-analysis]"}
}
},
["warn_acquired_before_after_cycle"]={
[j]={"thread-safety",Zb},
[k]=Zb,
[g]="warn_acquired_before_after_cycle",
[b]="Cycle in acquired_before/after dependencies, starting with \'%0\'",
[c]="Cycle in acquired_before/after dependencies, starting with \'A\'",
[d]=m,
[e]="Cycle in acquired_before\\/after dependencies, starting with \'(.*?)\'",
[f]=" \\[(?:\\-Werror,)?\\-Wthread\\-safety\\-analysis[^\\]]*\\]",
[h]=n,
[a]={"4980df623f15",1422987468,"Thread Safety Analysis: add support for before/after annotations on mutexes.","Thread Safety Analysis: add support for before/after annotations on mutexes.\nThese checks detect potential deadlocks caused by inconsistent lock\nordering. The checks are implemented under the -Wthread-safety-beta flag.\n\nllvm-svn: 227997"},
[i]={{M,2049,"class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {\n // ...\n void handleBeforeAfterCycle(Name L1Name, SourceLocation Loc) override {\n PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_acquired_before_after_cycle) << L1Name);"}},
[l]={
["clang/test/SemaCXX/warn-thread-safety-analysis.cpp"]={"clang/test/SemaCXX/warn-thread-safety-analysis.cpp:5758:9: warning: Cycle in acquired_before/after dependencies, starting with \'mu_b\' [-Wthread-safety-analysis]","clang/test/SemaCXX/warn-thread-safety-analysis.cpp:5759:9: warning: Cycle in acquired_before/after dependencies, starting with \'mu_a\' [-Wthread-safety-analysis]","clang/test/SemaCXX/warn-thread-safety-analysis.cpp:5756:9: warning: Cycle in acquired_before/after dependencies, starting with \'mu3\' [-Wthread-safety-analysis]","clang/test/SemaCXX/warn-thread-safety-analysis.cpp:5754:9: warning: Cycle in acquired_before/after dependencies, starting with \'mu1\' [-Wthread-safety-analysis]","clang/test/SemaCXX/warn-thread-safety-analysis.cpp:5755:9: warning: Cycle in acquired_before/after dependencies, starting with \'mu2\' [-Wthread-safety-analysis]"}
}
},
["warn_addition_in_bitshift"]={
[j]={P,T,"parentheses","shift-op-parentheses"},
[k]="shift-op-parentheses",
[g]="warn_addition_in_bitshift",
[b]="operator \'%0\' has lower precedence than \'%1\'; \'%1\' will be evaluated first",
[c]="operator \'A\' has lower precedence than \'B\'; \'B\' will be evaluated first",
[d]=m,
[e]="operator \'(.*?)\' has lower precedence than \'(.*?)\'; \'(.*?)\' will be evaluated first",
[f]=" \\[(?:\\-Werror,)?\\-Wshift\\-op\\-parentheses[^\\]]*\\]",
[h]=n,
[a]={"15f17cbbd813",1349397663,"Implement -Wshift-op-parentheses for: a << b + c","Implement -Wshift-op-parentheses for: a << b + c\n\nThis appears to be consistent with GCC\'s implementation of the same warning\nunder -Wparentheses. Suppressing a << b + c for cases where \'a\' is a user\ndefined type for compatibility with C++ stream IO. Otherwise suggest\nparentheses around the addition or subtraction subexpression.\n\n(this came up when MSVC was complaining (incorrectly, so far as I can tell)\nabout a perceived violation of this within the LLVM codebase, PR14001)\n\nllvm-svn: 165283"},
[i]={{G,15846,"static void DiagnoseAdditionInShift(Sema &S, SourceLocation OpLoc, Expr *SubExpr, StringRef Shift) {\n if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {\n if (Bop->getOpcode() == BO_Add || Bop->getOpcode() == BO_Sub) {\n // ...\n S.Diag(Bop->getOperatorLoc(), diag::warn_addition_in_bitshift) << Bop->getSourceRange() << OpLoc << Shift << Op;"}},
[l]={
["clang/test/Sema/parentheses.cpp"]={"clang/test/Sema/parentheses.cpp:88:17: warning: operator \'>>\' has lower precedence than \'+\'; \'+\' will be evaluated first [-Wshift-op-parentheses]","clang/test/Sema/parentheses.cpp:93:12: warning: operator \'<<\' has lower precedence than \'-\'; \'-\' will be evaluated first [-Wshift-op-parentheses]","clang/test/Sema/parentheses.cpp:99:17: warning: operator \'>>\' has lower precedence than \'+\'; \'+\' will be evaluated first [-Wshift-op-parentheses]"}
}
},
["warn_address_of_reference_bool_conversion"]={
[j]={"bool-conversion","bool-conversions",Bb,Cb,"undefined-bool-conversion"},
[k]="undefined-bool-conversion",
[g]="warn_address_of_reference_bool_conversion",
[b]="reference cannot be bound to dereferenced null pointer in well-defined C++ code; pointer may be assumed to always convert to true",
[c]="reference cannot be bound to dereferenced null pointer in well-defined C++ code; pointer may be assumed to always convert to true",
[d]=m,
[e]="reference cannot be bound to dereferenced null pointer in well\\-defined C\\+\\+ code; pointer may be assumed to always convert to true",
[f]=" \\[(?:\\-Werror,)?\\-Wundefined\\-bool\\-conversion[^\\]]*\\]",
[h]=ac,
[a]={"f7432755d0c0",1402090766,"Add -Wtautological-undefined-compare and -Wundefined-bool-conversion warnings","Add -Wtautological-undefined-compare and -Wundefined-bool-conversion warnings\nto detect underfined behavior involving pointers.\n\nllvm-svn: 210372"},
[i]={{u,15476,"/// Diagnose pointers that are always non-null.\n/// \\param E the expression containing the pointer\n/// \\param NullKind NPCK_NotNull if E is a cast to bool, otherwise, E is\n/// compared to a null pointer\n/// \\param IsEqual True when the comparison is equal to a null pointer\n/// \\param Range Extra SourceRange to highlight in the diagnostic\nvoid Sema::DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullKind, bool IsEqual, SourceRange Range) {\n // ...\n if (IsAddressOf) {\n unsigned DiagID = IsCompare ? diag::warn_address_of_reference_null_compare : diag::warn_address_of_reference_bool_conversion;"}},
[l]={
["clang/test/CodeGenCXX/reference-field.cpp"]={"clang/test/CodeGenCXX/reference-field.cpp:6:19: warning: reference cannot be bound to dereferenced null pointer in well-defined C++ code; pointer may be assumed to always convert to true [-Wundefined-bool-conversion]"}
}
},
["warn_address_of_reference_null_compare"]={
[j]={P,T,cb,Xb,"tautological-undefined-compare"},
[k]="tautological-undefined-compare",
[g]="warn_address_of_reference_null_compare",
[b]="reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to %select{true|false}0",
[c]={{nil,nil,{"reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to ",{"true","false"}}}},
[d]=m,
[e]="reference cannot be bound to dereferenced null pointer in well\\-defined C\\+\\+ code; comparison may be assumed to always evaluate to (?:true|false)",
[f]=" \\[(?:\\-Werror,)?\\-Wtautological\\-undefined\\-compare[^\\]]*\\]",
[h]=n,
[a]={"f7432755d0c0",1402090766,"Add -Wtautological-undefined-compare and -Wundefined-bool-conversion warnings","Add -Wtautological-undefined-compare and -Wundefined-bool-conversion warnings\nto detect underfined behavior involving pointers.\n\nllvm-svn: 210372"},
[i]={{u,15475,"/// Diagnose pointers that are always non-null.\n/// \\param E the expression containing the pointer\n/// \\param NullKind NPCK_NotNull if E is a cast to bool, otherwise, E is\n/// compared to a null pointer\n/// \\param IsEqual True when the comparison is equal to a null pointer\n/// \\param Range Extra SourceRange to highlight in the diagnostic\nvoid Sema::DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullKind, bool IsEqual, SourceRange Range) {\n // ...\n if (IsAddressOf) {\n unsigned DiagID = IsCompare ? diag::warn_address_of_reference_null_compare : diag::warn_address_of_reference_bool_conversion;"}},
[l]={
["clang/test/Analysis/loop-widening-preserve-reference-type.cpp"]={"clang/test/Analysis/loop-widening-preserve-reference-type.cpp:13:24: warning: reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to true [-Wtautological-undefined-compare]","clang/test/Analysis/loop-widening-preserve-reference-type.cpp:21:24: warning: reference cannot be bound to dereferenced null pointer in well-defined C++ code; comparison may be assumed to always evaluate to true [-Wtautological-undefined-compare]"}
}
},
["warn_alias_to_weak_alias"]={
[j]={x,q},
[k]=q,
[g]="warn_alias_to_weak_alias",
[b]="%select{alias|ifunc}2 will always resolve to %0 even if weak definition of %1 is overridden",
[c]={{nil,nil,{{"alias","ifunc"}," will always resolve to A even if weak definition of B is overridden"}}},
[d]=m,
[e]="(?:alias|ifunc) will always resolve to (.*?) even if weak definition of (.*?) is overridden",
[f]=y,
[h]={{nil,V,O},{Sc,nil,n}},
[a]={"a39fc6dd2afa",1395934040,"Handle and warn on aliases to weak aliases.","Handle and warn on aliases to weak aliases.\n\nThis produces valid IR now that llvm rejects aliases to weak aliases and warns\nthe user that the resolution is not changed if the weak alias is overridden.\n\nllvm-svn: 204935"},
[i]={{"clang/lib/CodeGen/CodeGenModule.cpp",667,"void CodeGenModule::checkAliases() {\n // ...\n for (const GlobalDecl &GD : Aliases) {\n // ...\n // We have to handle alias to weak aliases in here. LLVM itself disallows\n // this since the object semantics would not match the IL one. For\n // compatibility with gcc we implement it by just pointing the alias\n // to its aliasee\'s aliasee. We also warn, since the user is probably\n // expecting the link to be weak.\n if (auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {\n if (GA->isInterposable()) {\n Diags.Report(Location, diag::warn_alias_to_weak_alias) << GV->getName() << GA->getName() << IsIFunc;"}},
[l]={
["clang/test/Sema/attr-alias-elf.c"]={"clang/test/Sema/attr-alias-elf.c:62:33: warning: alias will always resolve to test2_bar even if weak definition of test2_foo is overridden [-Wignored-attributes]"}
}
},
["warn_alias_with_section"]={
[j]={x,q},
[k]=q,
[g]="warn_alias_with_section",
[b]="%select{alias|ifunc}1 will not be in section \'%0\' but in the same section as the %select{aliasee|resolver}2",
[c]={{nil,nil,{{"alias","ifunc"}," will not be in section \'A\' but in the same section as the ",{"aliasee","resolver"}}}},
[d]=m,
[e]="(?:alias|ifunc) will not be in section \'(.*?)\' but in the same section as the (?:aliasee|resolver)",
[f]=y,
[h]={{nil,V,O},{Sc,nil,n}},
[a]={"502f65ae54d0",1399321263,"Fix pr19653.","Fix pr19653.\n\nWarn if an alias requests a section other than the aliasee section.\n\nllvm-svn: 207997"},
[i]={{"clang/lib/CodeGen/CodeGenModule.cpp",656,"void CodeGenModule::checkAliases() {\n // ...\n for (const GlobalDecl &GD : Aliases) {\n // ...\n if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {\n // ...\n if (AliasSection != AliaseeGV->getSection())\n Diags.Report(SA->getLocation(), diag::warn_alias_with_section) << AliasSection << IsIFunc << IsIFunc;"}},
[l]={
["clang/test/Sema/attr-alias-elf.c"]={"clang/test/Sema/attr-alias-elf.c:65:33: warning: alias will not be in section \'test\' but in the same section as the aliasee [-Wignored-attributes]"}
}
},
["warn_aligned_attr_underaligned"]={
[j]={x,q},
[k]=q,
[g]={{nil,z,"warn_aligned_attr_underaligned"}},
[b]={{nil,z,"requested alignment is less than minimum alignment of %1 for type %0"}},
[c]={{nil,z,"requested alignment is less than minimum alignment of B for type A"}},
[d]=m,
[e]="requested alignment is less than minimum alignment of (.*?) for type (.*?)",
[f]=y,
[h]={{nil,z,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{o,4518,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, bool IsPackExpansion) {\n // ...\n // On AIX, an aligned attribute can not decrease the alignment when applied\n // to a variable declaration with vector type.\n if (VD && Context.getTargetInfo().getTriple().isOSAIX()) {\n // ...\n if (Ty->isVectorType() && AlignVal < 16) {\n Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned) << VD->getType() << 16;"},{o,4567,"void Sema::AddAlignedAttr(Decl *D, const AttributeCommonInfo &CI, TypeSourceInfo *TS, bool IsPackExpansion) {\n // ...\n // On AIX, an aligned attribute can not decrease the alignment when applied\n // to a variable declaration with vector type.\n if (VD && Context.getTargetInfo().getTriple().isOSAIX()) {\n // ...\n if (Ty->isVectorType() && Context.toCharUnitsFromBits(AlignVal).getQuantity() < 16) {\n Diag(VD->getLocation(), diag::warn_aligned_attr_underaligned) << VD->getType() << 16;"}},
[l]={
["clang/test/Sema/aix-attr-aligned-vector-warn.c"]={"clang/test/Sema/aix-attr-aligned-vector-warn.c:9:12: warning: requested alignment is less than minimum alignment of 16 for type \'__vector int\' (vector of 4 \'int\' values) [-Wignored-attributes]","clang/test/Sema/aix-attr-aligned-vector-warn.c:10:12: warning: requested alignment is less than minimum alignment of 16 for type \'__vector int\' (vector of 4 \'int\' values) [-Wignored-attributes]"}
}
},
["warn_alignment_builtin_useless"]={
[j]={P,T,cb,Xb},
[k]=Xb,
[g]={{nil,s,"warn_alignment_builtin_useless"}},
[b]={{nil,s,"%select{aligning a value|the result of checking whether a value is aligned}0 to 1 byte is %select{a no-op|always true}0"}},
[c]={{nil,s,{{"aligning a value","the result of checking whether a value is aligned"}," to 1 byte is ",{"a no-op","always true"}}}},
[d]=m,
[e]="(?:aligning a value|the result of checking whether a value is aligned) to 1 byte is (?:a no\\-op|always true)",
[f]=" \\[(?:\\-Werror,)?\\-Wtautological\\-compare[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"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"},
[i]={{u,343,"/// Check that the value argument for __builtin_is_aligned(value, alignment) and\n/// __builtin_aligned_{up,down}(value, alignment) is an integer or a pointer\n/// type (but not a function pointer) and that the alignment is a power-of-two.\nstatic bool SemaBuiltinAlignment(Sema &S, CallExpr *TheCall, unsigned ID) {\n // ...\n // We can\'t check validity of alignment if it is value dependent.\n if (!AlignOp->isValueDependent() && AlignOp->EvaluateAsInt(AlignResult, S.Context, Expr::SE_AllowSideEffects)) {\n // ...\n if (AlignValue == 1) {\n S.Diag(AlignOp->getExprLoc(), diag::warn_alignment_builtin_useless) << IsBooleanAlignBuiltin;"}},
[l]={
["clang/test/Sema/builtin-align.c"]={"clang/test/Sema/builtin-align.c:80:28: warning: the result of checking whether a value is aligned to 1 byte is always true [-Wtautological-compare]"}
}
},
["warn_alignment_not_power_of_two"]={
[j]={"non-power-of-two-alignment"},
[k]="non-power-of-two-alignment",
[g]={{nil,t,"warn_alignment_not_power_of_two"}},
[b]={{nil,t,"requested alignment is not a power of 2"}},
[c]={{nil,t,"requested alignment is not a power of 2"}},
[d]=m,
[e]="requested alignment is not a power of 2",
[f]=" \\[(?:\\-Werror,)?\\-Wnon\\-power\\-of\\-two\\-alignment[^\\]]*\\]",
[h]={{nil,t,n}},
[a]={"931fcd3ba011",1576908663,"[WebAssembly] Improve clang diagnostics for wasm attributes","[WebAssembly] Improve clang diagnostics for wasm attributes\n\nThis patch addresses the review comments on r352930:\n\n - Removes redundant diagnostic checking code\n - Removes errnoneous use of diag::err_alias_is_definition, which\n turned out to be ineffective anyway since functions can be defined later\n in the translation unit and avoid detection.\n - Adds a test for various invalid cases for import_name and import_module.\n\nDifferential Revision: https://reviews.llvm.org/D59520"},
[i]={{u,6741,"/// Handles the checks for format strings, non-POD arguments to vararg\n/// functions, NULL arguments passed to non-NULL parameters, and diagnose_if\n/// attributes.\nvoid Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef<const Expr *> Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType) {\n // ...\n if (FDecl && FDecl->hasAttr<AllocAlignAttr>()) {\n // ...\n if (!Arg->isValueDependent()) {\n // ...\n if (Arg->EvaluateAsInt(Align, Context)) {\n // ...\n if (!I.isPowerOf2())\n Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two) << Arg->getSourceRange();"}},
[l]={
["clang/test/Sema/alloc-align-attr.c"]={"clang/test/Sema/alloc-align-attr.c:27:31: warning: requested alignment is not a power of 2 [-Wnon-power-of-two-alignment]"}
}
},
["warn_alloca"]={
[j]={"alloca"},
[k]="alloca",
[g]={{nil,s,"warn_alloca"}},
[b]={{nil,s,"use of function %0 is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability"}},
[c]={{nil,s,"use of function A is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability"}},
[d]=m,
[e]="use of function (.*?) is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability",
[f]=" \\[(?:\\-Werror,)?\\-Walloca[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"9d045a5c1e6b",1564093420,"[Sema] add -Walloca to flag uses of `alloca`","[Sema] add -Walloca to flag uses of `alloca`\n\nThis CL adds an optional warning to diagnose uses of the\n`__builtin_alloca` family of functions. The use of these functions is\ndiscouraged by many, so it seems like a good idea to allow clang to warn\nabout it.\n\nPatch by Elaina Guan!\n\nDifferential Revision: https://reviews.llvm.org/D64883\n\nllvm-svn: 367067"},
[i]={{u,2205,"ExprResult Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, CallExpr *TheCall) {\n // ...\n case Builtin::BI__builtin_alloca:\n case Builtin::BI__builtin_alloca_uninitialized:\n Diag(TheCall->getBeginLoc(), diag::warn_alloca) << TheCall->getDirectCallee();"}},
[l]={
["clang/test/Sema/warn-alloca.c"]={"clang/test/Sema/warn-alloca.c:9:3: warning: use of function \'__builtin_alloca\' is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability [-Walloca]","clang/test/Sema/warn-alloca.c:16:3: warning: use of function \'__builtin_alloca_with_align\' is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability [-Walloca]","clang/test/Sema/warn-alloca.c:23:3: warning: use of function \'__builtin_alloca_uninitialized\' is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability [-Walloca]","clang/test/Sema/warn-alloca.c:30:3: warning: use of function \'__builtin_alloca_with_align_uninitialized\' is discouraged; there is no way to check for failure but failure may still occur, resulting in a possibly exploitable security vulnerability [-Walloca]"}
}
},
["warn_alloca_align_alignof"]={
[j]={"alloca-with-align-alignof"},
[k]="alloca-with-align-alignof",
[g]="warn_alloca_align_alignof",
[b]="second argument to __builtin_alloca_with_align is supposed to be in bits",
[c]="second argument to __builtin_alloca_with_align is supposed to be in bits",
[d]=m,
[e]="second argument to __builtin_alloca_with_align is supposed to be in bits",
[f]=" \\[(?:\\-Werror,)?\\-Walloca\\-with\\-align\\-alignof[^\\]]*\\]",
[h]=n,
[a]={"86b1bfad0509",1477937277,"[Sema] Warn when alignof is used with __builtin_alloca_with_align","[Sema] Warn when alignof is used with __builtin_alloca_with_align\n\nThe second argument to __builtin_alloca_with_align is supposed to be in\nbits, not bytes. Using alignof there would be indicative of a bug.\n\nllvm-svn: 285609"},
[i]={{u,8625,"/// Handle __builtin_alloca_with_align. This is declared\n/// as (size_t, size_t) where the second size_t must be a power of 2 greater\n/// than 8.\nbool Sema::SemaBuiltinAllocaWithAlign(CallExpr *TheCall) {\n // ...\n // We can\'t check the value of a dependent argument.\n if (!Arg->isTypeDependent() && !Arg->isValueDependent()) {\n if (const auto *UE = dyn_cast<UnaryExprOrTypeTraitExpr>(Arg->IgnoreParenImpCasts()))\n if (UE->getKind() == UETT_AlignOf || UE->getKind() == UETT_PreferredAlignOf)\n Diag(TheCall->getBeginLoc(), diag::warn_alloca_align_alignof) << Arg->getSourceRange();"}},
[l]={
["clang/test/Sema/builtin-alloca-with-align.c"]={"clang/test/Sema/builtin-alloca-with-align.c:32:3: warning: second argument to __builtin_alloca_with_align is supposed to be in bits [-Walloca-with-align-alignof]"}
}
},
["warn_always_inline_coroutine"]={
[j]={"always-inline-coroutine","coroutine"},
[k]="always-inline-coroutine",
[g]={{nil,D,"warn_always_inline_coroutine"}},
[b]={{nil,D,"this coroutine may be split into pieces; not every piece is guaranteed to be inlined"}},
[c]={{nil,D,"this coroutine may be split into pieces; not every piece is guaranteed to be inlined"}},
[d]=m,
[e]="this coroutine may be split into pieces; not every piece is guaranteed to be inlined",
[f]=" \\[(?:\\-Werror,)?\\-Walways\\-inline\\-coroutine[^\\]]*\\]",
[h]={{nil,D,"Coroutines Issue"}},
[a]={"f9c3310d32c6",1616787805,"[OPENMP]Fix PR49366: crash on VLAs in task untied regions.","[OPENMP]Fix PR49366: crash on VLAs in task untied regions.\n\nWe need to capture the local variables into a record in task untied\nregions but clang does not support record with VLA data members.\n\nDifferential Revision: https://reviews.llvm.org/D99436"},
[i]={{"clang/lib/Sema/SemaCoroutine.cpp",1116,"void Sema::CheckCompletedCoroutineBody(FunctionDecl *FD, Stmt *&Body) {\n // ...\n // The always_inline attribute doesn\'t reliably apply to a coroutine,\n // because the coroutine will be split into pieces and some pieces\n // might be called indirectly, as in a virtual call. Even the ramp\n // function cannot be inlined at -O0, due to pipeline ordering\n // problems (see https://llvm.org/PR53413). Tell the user about it.\n if (FD->hasAttr<AlwaysInlineAttr>())\n Diag(FD->getLocation(), diag::warn_always_inline_coroutine);"}},
[l]={
["clang/test/CodeGenCoroutines/coro-always-inline.cpp"]={"clang/test/CodeGenCoroutines/coro-always-inline.cpp:44:41: warning: this coroutine may be split into pieces; not every piece is guaranteed to be inlined [-Walways-inline-coroutine]"}
}
},
["warn_ambiguous_suitable_delete_function_found"]={
[j]={"ambiguous-delete"},
[k]="ambiguous-delete",
[g]="warn_ambiguous_suitable_delete_function_found",
[b]="multiple suitable %0 functions for %1; no \'operator delete\' function will be invoked if initialization throws an exception",
[c]="multiple suitable A functions for B; no \'operator delete\' function will be invoked if initialization throws an exception",
[d]=m,
[e]="multiple suitable (.*?) functions for (.*?); no \'operator delete\' function will be invoked if initialization throws an exception",
[f]=" \\[(?:\\-Werror,)?\\-Wambiguous\\-delete[^\\]]*\\]",
[h]=n,
[a]={"189e52fcdfc3",1476081751,"P0035R4: Semantic analysis and code generation for C++17 overaligned","P0035R4: Semantic analysis and code generation for C++17 overaligned\nallocation.\n\nllvm-svn: 283722"},
[i]={{"clang/lib/Sema/SemaExprCXX.cpp",2939,"bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, AllocationFunctionScope NewScope, AllocationFunctionScope DeleteScope, QualType AllocType, bool IsArray, bool &PassAlignment, MultiExprArg PlaceArgs, FunctionDecl *&OperatorNew, FunctionDecl *&OperatorDelete, bool Diagnose) {\n // ...\n // C++ [expr.new]p20:\n // [...] If the lookup finds a single matching deallocation\n // function, that function will be called; otherwise, no\n // deallocation function will be called.\n if (Matches.size() == 1) {\n // ...\n } else if (!Matches.empty()) {\n // ...\n Diag(StartLoc, diag::warn_ambiguous_suitable_delete_function_found) << DeleteName << AllocElemType;"}}
},
["warn_analyzer_deprecated_option"]={
[j]={"deprecated-static-analyzer-flag"},
[k]="deprecated-static-analyzer-flag",
[g]={{nil,D,"warn_analyzer_deprecated_option"}},
[b]={{nil,D,"analyzer option \'%0\' is deprecated. This flag will be removed in %1, and passing this option will be an error."}},
[c]={{nil,D,"analyzer option \'A\' is deprecated. This flag will be removed in B, and passing this option will be an error."}},
[d]=m,
[e]="analyzer option \'(.*?)\' is deprecated\\. This flag will be removed in (.*?), and passing this option will be an error\\.",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-static\\-analyzer\\-flag[^\\]]*\\]",
[h]={{nil,D,O}},
[a]={"aef03c9b3bed",1651866463,"[clang][auto-init] Deprecate -enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clan...","[clang][auto-init] Deprecate -enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang\n\nGCC 12 has been released and contains unconditional support for\n-ftrivial-auto-var-init=zero:\nhttps://gcc.gnu.org/onlinedocs/gcc/Optimize-Options.html#index-ftrivial-auto-var-init\n\nMaintain compatibility with GCC, and remove the -enable flag for \"zero\"\nmode. The flag is left to generate an \"unused\" warning, though, to not\nbreak all the existing users. The flag will be fully removed in Clang 17.\n\nLink: https://github.com/llvm/llvm-project/issues/44842\n\nReviewed By: nickdesaulniers, MaskRay, srhines, xbolva00\n\nDifferential Revision: https://reviews.llvm.org/D125142"}
},
["warn_analyzer_deprecated_option_with_alternative"]={
[j]={"deprecated-static-analyzer-flag"},
[k]="deprecated-static-analyzer-flag",
[g]={{nil,v,"warn_analyzer_deprecated_option_with_alternative"}},
[b]={{nil,v,"analyzer option \'%0\' is deprecated. This flag will be removed in %1, and passing this option will be an error. Use \'%2\' instead."}},
[c]={{nil,v,"analyzer option \'A\' is deprecated. This flag will be removed in B, and passing this option will be an error. Use \'C\' instead."}},
[d]=m,
[e]="analyzer option \'(.*?)\' is deprecated\\. This flag will be removed in (.*?), and passing this option will be an error\\. Use \'(.*?)\' instead\\.",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-static\\-analyzer\\-flag[^\\]]*\\]",
[h]={{nil,v,O}},
[a]={"3738ce05a70c",1668637223,"Add support for a backdoor driver option that enables emitting header","Add support for a backdoor driver option that enables emitting header\nusage information in JSON to a file\n\nEach line in the file is a JSON object that has the name of the main\nsource file followed by the list of system header files included\ndirectly or indirectly from that file.\n\nFor example:\n\n{\"source\":\"/tmp/foo.c\",\n \"includes\":[\"/usr/include/stdio.h\", \"/usr/include/stdlib.h\"]}\n\nTo reduce the amount of data written to the file, only the system\nheaders that are directly included from a non-system header file are\nrecorded.\n\nIn order to emit the header information in JSON, it is necessary to set\nthe following environment variables:\n\nCC_PRINT_HEADERS_FORMAT=json CC_PRINT_HEADERS_FILTERING=only-direct-system\n\nThe following combination is equivalent to setting CC_PRINT_HEADERS=1:\n\nCC_PRINT_HEADERS_FORMAT=textual CC_PRINT_HEADERS_FILTERING=none\n\nDifferential Revision: https://reviews.llvm.org/D137996"}
},
["warn_anyx86_interrupt_regsave"]={
[j]={"interrupt-service-routine"},
[k]="interrupt-service-routine",
[g]={{nil,w,"warn_anyx86_interrupt_regsave"}},
[b]={{nil,w,"interrupt service routine should only call a function with attribute \'no_caller_saved_registers\'"}},
[c]={{nil,w,"interrupt service routine should only call a function with attribute \'no_caller_saved_registers\'"}},
[d]=m,
[e]="interrupt service routine should only call a function with attribute \'no_caller_saved_registers\'",
[f]=" \\[(?:\\-Werror,)?\\-Winterrupt\\-service\\-routine[^\\]]*\\]",
[h]={{nil,w,n}},
[a]={"b83b23275b74",1607502387,"Introduce -Wreserved-identifier","Introduce -Wreserved-identifier\n\nWarn when a declaration uses an identifier that doesn\'t obey the reserved\nidentifier rule from C and/or C++.\n\nDifferential Revision: https://reviews.llvm.org/D93095"},
[i]={{G,7365,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy. The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n // ...\n // Interrupt handlers don\'t save off the VFP regs automatically on ARM,\n // so there\'s some risk when calling out to non-interrupt handler functions\n // that the callee might not preserve them. This is easy to diagnose here,\n // but can be very challenging to debug.\n // Likewise, X86 interrupt handlers may only call routines with attribute\n // no_caller_saved_registers since there is no efficient way to\n // save and restore the non-GPR state.\n if (auto *Caller = getCurFunctionDecl()) {\n // ...\n if (Caller->hasAttr<AnyX86InterruptAttr>() && ((!FDecl || !FDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>()))) {\n Diag(Fn->getExprLoc(), diag::warn_anyx86_interrupt_regsave);"}},
[l]={
["clang/test/Sema/attr-x86-interrupt.c"]={"clang/test/Sema/attr-x86-interrupt.c:58:3: warning: interrupt service routine should only call a function with attribute \'no_caller_saved_registers\' [-Winterrupt-service-routine]"}
}
},
["warn_arc_bridge_cast_nonarc"]={
[j]={"arc-bridge-casts-disallowed-in-nonarc"},
[k]="arc-bridge-casts-disallowed-in-nonarc",
[g]="warn_arc_bridge_cast_nonarc",
[b]="\'%0\' casts have no effect when not using ARC",
[c]="\'A\' casts have no effect when not using ARC",
[d]=m,
[e]="\'(.*?)\' casts have no effect when not using ARC",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-bridge\\-casts\\-disallowed\\-in\\-nonarc[^\\]]*\\]",
[h]="ARC Parse Issue",
[a]={"084e1b48a176",1329540158,"Change wording of warning about using __bridge casts in non-ARC.","Change wording of warning about using __bridge casts in non-ARC.\n\nllvm-svn: 150868"},
[i]={{"clang/lib/Parse/ParseExpr.cpp",2922,"/// ParseParenExpression - This parses the unit that starts with a \'(\' token,\n/// based on what is allowed by ExprType. The actual thing parsed is returned\n/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,\n/// not the parsed cast-expression.\n///\n/// \\verbatim\n/// primary-expression: [C99 6.5.1]\n/// \'(\' expression \')\'\n/// [GNU] \'(\' compound-statement \')\' (if !ParenExprOnly)\n/// postfix-expression: [C99 6.5.2]\n/// \'(\' type-name \')\' \'{\' initializer-list \'}\'\n/// \'(\' type-name \')\' \'{\' initializer-list \',\' \'}\'\n/// cast-expression: [C99 6.5.4]\n/// \'(\' type-name \')\' cast-expression\n/// [ARC] bridged-cast-expression\n/// [ARC] bridged-cast-expression:\n/// (__bridge type-name) cast-expression\n/// (__bridge_transfer type-name) cast-expression\n/// (__bridge_retained type-name) cast-expression\n/// fold-expression: [C++1z]\n/// \'(\' cast-expression fold-operator \'...\' \')\'\n/// \'(\' \'...\' fold-operator cast-expression \')\'\n/// \'(\' cast-expression fold-operator \'...\'\n/// fold-operator cast-expression \')\'\n/// [OPENMP] Array shaping operation\n/// \'(\' \'[\' expression \']\' { \'[\' expression \']\' } cast-expression\n/// \\endverbatim\nExprResult Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, bool isTypeCast, ParsedType &CastTy, SourceLocation &RParenLoc) {\n // ...\n if (BridgeCast && !getLangOpts().ObjCAutoRefCount) {\n if (!TryConsumeToken(tok::kw___bridge)) {\n // ...\n if (!PP.getSourceManager().isInSystemHeader(BridgeKeywordLoc))\n Diag(BridgeKeywordLoc, diag::warn_arc_bridge_cast_nonarc) << BridgeCastName << FixItHint::CreateReplacement(BridgeKeywordLoc, \"\");"}},
[l]={
["clang/test/FixIt/bridge-in-non-arc.m"]={"clang/test/FixIt/bridge-in-non-arc.m:7:11: warning: \'__bridge_transfer\' casts have no effect when not using ARC [-Warc-bridge-casts-disallowed-in-nonarc]","clang/test/FixIt/bridge-in-non-arc.m:8:12: warning: \'__bridge_transfer\' casts have no effect when not using ARC [-Warc-bridge-casts-disallowed-in-nonarc]"}
}
},
["warn_arc_lifetime_result_type"]={
[j]={r,P,Nc,"ignored-qualifiers"},
[k]="ignored-qualifiers",
[g]="warn_arc_lifetime_result_type",
[b]="ARC %select{unused|__unsafe_unretained|__strong|__weak|__autoreleasing}0 lifetime qualifier on return type is ignored",
[c]={{nil,nil,{"ARC ",{"unused","__unsafe_unretained","__strong","__weak","__autoreleasing"}," lifetime qualifier on return type is ignored"}}},
[d]=m,
[e]="ARC (?:unused|__unsafe_unretained|__strong|__weak|__autoreleasing) lifetime qualifier on return type is ignored",
[f]=" \\[(?:\\-Werror,)?\\-Wignored\\-qualifiers[^\\]]*\\]",
[h]=oc,
[a]={"cd78037ad117",1358465805,"In Objective-C ARC, completely ignore ownership qualifiers on the","In Objective-C ARC, completely ignore ownership qualifiers on the\nreturn type of a function by canonicalizing them away. They are\nuseless anyway, and conflict with our rules for template argument\ndeduction and __strong. Fixes <rdar://problem/12367446>.\n\nllvm-svn: 172768"},
[i]={{lb,5402,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n // ...\n for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n // ...\n case DeclaratorChunk::Function: {\n // ...\n // Objective-C ARC ownership qualifiers are ignored on the function\n // return type (by type canonicalization). Complain if this attribute\n // was written here.\n if (T.getQualifiers().hasObjCLifetime()) {\n // ...\n if (AttrLoc.isValid()) {\n // ...\n S.Diag(AttrLoc, diag::warn_arc_lifetime_result_type) << T.getQualifiers().getObjCLifetime();"}},
[l]={
["clang/test/CodeGenObjCXX/msabi-objc-extensions.mm"]={"clang/test/CodeGenObjCXX/msabi-objc-extensions.mm:66:1: warning: ARC __autoreleasing lifetime qualifier on return type is ignored [-Wignored-qualifiers]"}
}
},
["warn_arc_literal_assign"]={
[j]={Rc,ic},
[k]=ic,
[g]="warn_arc_literal_assign",
[b]="assigning %select{array literal|dictionary literal|numeric literal|boxed expression|<should not happen>|block literal}0 to a weak %select{property|variable}1; object will be released after assignment",
[c]={{nil,nil,{"assigning ",{"array literal","dictionary literal","numeric literal","boxed expression","block literal"}," to a weak ",{"property",Kc},"; object will be released after assignment"}}},
[d]=m,
[e]="assigning (?:array literal|dictionary literal|numeric literal|boxed expression|block literal) to a weak (?:property|variable); object will be released after assignment",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-unsafe\\-retained\\-assign[^\\]]*\\]",
[h]=oc,
[a]={"9304da95784c",1356077068,"Extend checkUnsafeAssigns() to also handle assigning an object literal to a weak reference.","Extend checkUnsafeAssigns() to also handle assigning an object literal to a weak reference.\n\nThanks to Jordan Rose and John McCall for their sage code review.\n\nFixes <rdar://problem/12569201>.\n\nllvm-svn: 170864"},
[i]={{u,17735,"static bool checkUnsafeAssignLiteral(Sema &S, SourceLocation Loc, Expr *RHS, bool isProperty) {\n // ...\n S.Diag(Loc, diag::warn_arc_literal_assign) << (unsigned)Kind << (isProperty ? 0 : 1) << RHS->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/arc.m"]={"clang/test/SemaObjC/arc.m:758:15: warning: assigning dictionary literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:759:15: warning: assigning array literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:760:15: warning: assigning block literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:761:15: warning: assigning numeric literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:762:15: warning: assigning numeric literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:763:15: warning: assigning boxed expression to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:766:7: warning: assigning dictionary literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:767:7: warning: assigning array literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:768:7: warning: assigning block literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:769:7: warning: assigning numeric literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:770:7: warning: assigning numeric literal to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc.m:771:7: warning: assigning boxed expression to a weak variable; object will be released after assignment [-Warc-unsafe-retained-assign]"}
}
},
["warn_arc_object_memaccess"]={
[j]={Rc,"arc-non-pod-memaccess"},
[k]="arc-non-pod-memaccess",
[g]="warn_arc_object_memaccess",
[b]="%select{destination for|source of}0 this %1 call is a pointer to ownership-qualified type %2",
[c]={{nil,nil,{{"destination for","source of"}," this B call is a pointer to ownership-qualified type C"}}},
[d]=m,
[e]="(?:destination for|source of) this (.*?) call is a pointer to ownership\\-qualified type (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-non\\-pod\\-memaccess[^\\]]*\\]",
[h]=oc,
[a]={"31168b077c36",1308178962,"Automatic Reference Counting.","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"},
[i]={{u,12580,"/// Check for dangerous or invalid arguments to memset().\n///\n/// This issues warnings on known problematic, dangerous or unspecified\n/// arguments to the standard \'memset\', \'memcpy\', \'memmove\', and \'memcmp\'\n/// function calls.\n///\n/// \\param Call The call expression to diagnose.\nvoid Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) {\n // ...\n for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {\n // ...\n if (const CXXRecordDecl *ContainedRD = getContainedDynamicClass(PointeeTy, IsContained)) {\n // ...\n } else if (PointeeTy.hasNonTrivialObjCLifetime() && BId != Builtin::BImemset)\n DiagRuntimeBehavior(Dest->getExprLoc(), Dest, PDiag(diag::warn_arc_object_memaccess) << ArgIdx << FnName << PointeeTy << Call->getCallee()->getSourceRange());"}},
[l]={
["clang/test/SemaObjC/arc-non-pod-memaccess.m"]={"clang/test/SemaObjC/arc-non-pod-memaccess.m:24:10: warning: destination for this \'memcpy\' call is a pointer to ownership-qualified type \'__strong id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:26:10: warning: destination for this \'memcpy\' call is a pointer to ownership-qualified type \'__weak id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:28:10: warning: destination for this \'memcpy\' call is a pointer to ownership-qualified type \'__autoreleasing id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:32:15: warning: source of this \'memcpy\' call is a pointer to ownership-qualified type \'__strong id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:34:15: warning: source of this \'memcpy\' call is a pointer to ownership-qualified type \'__weak id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:36:15: warning: source of this \'memcpy\' call is a pointer to ownership-qualified type \'__autoreleasing id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:40:11: warning: destination for this \'memmove\' call is a pointer to ownership-qualified type \'__strong id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:42:11: warning: destination for this \'memmove\' call is a pointer to ownership-qualified type \'__weak id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:44:11: warning: destination for this \'memmove\' call is a pointer to ownership-qualified type \'__autoreleasing id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:48:16: warning: source of this \'memmove\' call is a pointer to ownership-qualified type \'__strong id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:50:16: warning: source of this \'memmove\' call is a pointer to ownership-qualified type \'__weak id\' [-Warc-non-pod-memaccess]","clang/test/SemaObjC/arc-non-pod-memaccess.m:52:16: warning: source of this \'memmove\' call is a pointer to ownership-qualified type \'__autoreleasing id\' [-Warc-non-pod-memaccess]"}
}
},
["warn_arc_perform_selector_leaks"]={
[j]={"arc-performSelector-leaks"},
[k]="arc-performSelector-leaks",
[g]="warn_arc_perform_selector_leaks",
[b]="performSelector may cause a leak because its selector is unknown",
[c]="performSelector may cause a leak because its selector is unknown",
[d]=m,
[e]="performSelector may cause a leak because its selector is unknown",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-performSelector\\-leaks[^\\]]*\\]",
[h]=n,
[a]={"b7a773626fea",1309905539,"objc-arc: enforce performSelector rules in rejecting retaining selectors","objc-arc: enforce performSelector rules in rejecting retaining selectors\npassed to it, and unknown selectors causing potential leak.\n// rdar://9659270\n\nllvm-svn: 134449"},
[i]={{ec,3316,"/// Build an Objective-C instance message expression.\n///\n/// This routine takes care of both normal instance messages and\n/// instance messages to the superclass instance.\n///\n/// \\param Receiver The expression that computes the object that will\n/// receive this message. This may be empty, in which case we are\n/// sending to the superclass instance and \\p SuperLoc must be a valid\n/// source location.\n///\n/// \\param ReceiverType The (static) type of the object receiving the\n/// message. When a \\p Receiver expression is provided, this is the\n/// same type as that expression. For a superclass instance send, this\n/// is a pointer to the type of the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass instance message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this instance message is invoking, if\n/// already known.\n///\n/// \\param LBracLoc The location of the opening square bracket \']\'.\n///\n/// \\param RBracLoc The location of the closing square bracket \']\'.\n///\n/// \\param ArgsIn The message arguments.\nExprResult Sema::BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n // ...\n // In ARC, forbid the user from sending messages to\n // retain/release/autorelease/dealloc/retainCount explicitly.\n if (getLangOpts().ObjCAutoRefCount) {\n // ...\n case OMF_performSelector:\n if (Method && NumArgs >= 1) {\n if (const auto *SelExp = dyn_cast<ObjCSelectorExpr>(Args[0]->IgnoreParens())) {\n // ...\n } else {\n // ...\n Diag(SelLoc, diag::warn_arc_perform_selector_leaks);"}},
[l]={
["clang/test/SemaObjC/arc-peformselector.m"]={"clang/test/SemaObjC/arc-peformselector.m:32:16: warning: performSelector may cause a leak because its selector is unknown [-Warc-performSelector-leaks]"}
}
},
["warn_arc_possible_repeated_use_of_weak"]={
[j]={"arc-maybe-repeated-use-of-weak","arc-repeated-use-of-weak"},
[k]="arc-maybe-repeated-use-of-weak",
[g]="warn_arc_possible_repeated_use_of_weak",
[b]="weak %select{variable|property|implicit property|instance variable}0 %1 may be accessed multiple times in this %select{function|method|block|lambda}2 and may be unpredictably set to nil; assign to a strong variable to keep the object alive",
[c]={{nil,nil,{"weak ",{Kc,"property","implicit property","instance variable"}," B may be accessed multiple times in this ",{sc,"method","block","lambda"}," and may be unpredictably set to nil; assign to a strong variable to keep the object alive"}}},
[d]=m,
[e]="weak (?:variable|property|implicit property|instance variable) (.*?) may be accessed multiple times in this (?:function|method|block|lambda) and may be unpredictably set to nil; assign to a strong variable to keep the object alive",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-maybe\\-repeated\\-use\\-of\\-weak[^\\]]*\\]",
[h]=n,
[a]={"d393458c3316",1348870890,"Add a warning (off by default) for repeated use of the same weak property.","Add a warning (off by default) for repeated use of the same weak property.\n\nThe motivating example:\n\nif (self.weakProp)\n use(self.weakProp);\n\nAs with any non-atomic test-then-use, it is possible a weak property to be\nnon-nil at the \'if\', but be deallocated by the time it is used. The correct\nway to write this example is as follows:\n\nid tmp = self.weakProp;\nif (tmp)\n use(tmp);\n\nThe warning is controlled by -Warc-repeated-use-of-receiver, and uses the\nproperty name and base to determine if the same property on the same object\nis being accessed multiple times. In cases where the base is more\ncomplicated than just a single Decl (e.g. \'foo.bar.weakProp\'), it picks a\nDecl for some degree of uniquing and reports the problem under a subflag,\n-Warc-maybe-repeated-use-of-receiver. This gives a way to tune the\naggressiveness of the warning for a particular project.\n\nThe warning is not on by default because it is not flow-sensitive and thus\nmay have a higher-than-acceptable rate of false positives, though it is\nless noisy than -Wreceiver-is-weak. On the other hand, it will not warn\nabout some cases that may be legitimate issues that -Wreceiver-is-weak\nwill catch, and it does not attempt to reason about methods returning weak\nvalues.\n\nEven though this is not a real \"analysis-based\" check I\'ve put the bug\nemission code in AnalysisBasedWarnings for two reasons: (1) to run on\nevery kind of code body (function, method, block, or lambda), and (2) to\nsuggest that it may be enhanced by flow-sensitive analysis in the future.\n\nThe second (smaller) half of this work is to extend it to weak locals\nand weak ivars. This should use most of the same infrastructure.\n\nPart of <rdar://problem/12280249>\n\nllvm-svn: 164854"},
[i]={{M,1472,"static void diagnoseRepeatedUseOfWeak(Sema &S, const sema::FunctionScopeInfo *CurFn, const Decl *D, const ParentMap &PM) {\n // ...\n // Iterate through the sorted problems and emit warnings for each.\n for (const auto &P : UsesByStmt) {\n // ...\n if (Key.isExactProfile())\n // ...\n else\n DiagKind = diag::warn_arc_possible_repeated_use_of_weak;"}},
[l]={
["clang/test/SemaObjC/arc-repeated-weak.mm"]={"clang/test/SemaObjC/arc-repeated-weak.mm:67:7: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:72:7: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:386:9: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:413:7: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:420:7: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:471:7: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:475:7: warning: weak property \'weakProp\' may be accessed multiple times in this function and may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-maybe-repeated-use-of-weak]"}
}
},
["warn_arc_repeated_use_of_weak"]={
[j]={"arc-repeated-use-of-weak"},
[k]="arc-repeated-use-of-weak",
[g]="warn_arc_repeated_use_of_weak",
[b]="weak %select{variable|property|implicit property|instance variable}0 %1 is accessed multiple times in this %select{function|method|block|lambda}2 but may be unpredictably set to nil; assign to a strong variable to keep the object alive",
[c]={{nil,nil,{"weak ",{Kc,"property","implicit property","instance variable"}," B is accessed multiple times in this ",{sc,"method","block","lambda"}," but may be unpredictably set to nil; assign to a strong variable to keep the object alive"}}},
[d]=m,
[e]="weak (?:variable|property|implicit property|instance variable) (.*?) is accessed multiple times in this (?:function|method|block|lambda) but may be unpredictably set to nil; assign to a strong variable to keep the object alive",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-repeated\\-use\\-of\\-weak[^\\]]*\\]",
[h]=n,
[a]={"d393458c3316",1348870890,"Add a warning (off by default) for repeated use of the same weak property.","Add a warning (off by default) for repeated use of the same weak property.\n\nThe motivating example:\n\nif (self.weakProp)\n use(self.weakProp);\n\nAs with any non-atomic test-then-use, it is possible a weak property to be\nnon-nil at the \'if\', but be deallocated by the time it is used. The correct\nway to write this example is as follows:\n\nid tmp = self.weakProp;\nif (tmp)\n use(tmp);\n\nThe warning is controlled by -Warc-repeated-use-of-receiver, and uses the\nproperty name and base to determine if the same property on the same object\nis being accessed multiple times. In cases where the base is more\ncomplicated than just a single Decl (e.g. \'foo.bar.weakProp\'), it picks a\nDecl for some degree of uniquing and reports the problem under a subflag,\n-Warc-maybe-repeated-use-of-receiver. This gives a way to tune the\naggressiveness of the warning for a particular project.\n\nThe warning is not on by default because it is not flow-sensitive and thus\nmay have a higher-than-acceptable rate of false positives, though it is\nless noisy than -Wreceiver-is-weak. On the other hand, it will not warn\nabout some cases that may be legitimate issues that -Wreceiver-is-weak\nwill catch, and it does not attempt to reason about methods returning weak\nvalues.\n\nEven though this is not a real \"analysis-based\" check I\'ve put the bug\nemission code in AnalysisBasedWarnings for two reasons: (1) to run on\nevery kind of code body (function, method, block, or lambda), and (2) to\nsuggest that it may be enhanced by flow-sensitive analysis in the future.\n\nThe second (smaller) half of this work is to extend it to weak locals\nand weak ivars. This should use most of the same infrastructure.\n\nPart of <rdar://problem/12280249>\n\nllvm-svn: 164854"},
[i]={{M,1470,"static void diagnoseRepeatedUseOfWeak(Sema &S, const sema::FunctionScopeInfo *CurFn, const Decl *D, const ParentMap &PM) {\n // ...\n // Iterate through the sorted problems and emit warnings for each.\n for (const auto &P : UsesByStmt) {\n // ...\n if (Key.isExactProfile())\n DiagKind = diag::warn_arc_repeated_use_of_weak;"},{M,2675,"void clang::sema::AnalysisBasedWarnings::IssueWarnings(sema::AnalysisBasedWarnings::Policy P, sema::FunctionScopeInfo *fscope, const Decl *D, QualType BlockType) {\n // ...\n if (S.getLangOpts().ObjCWeak && !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, D->getBeginLoc()))"},{u,17797,"void Sema::checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS) {\n // ...\n if (LT == Qualifiers::OCL_Weak) {\n if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))"},{H,13379,"/// 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->isInvalidDecl()) {\n // ...\n // It is safe to assign a weak reference into a strong variable.\n // Although this code can still have problems:\n // id x = self.weakProp;\n // id y = self.weakProp;\n // we do not warn to warn spuriously when \'x\' and \'y\' are on separate\n // paths through the function. This should be revisited if\n // -Wrepeated-use-of-weak is made flow-sensitive.\n if (FunctionScopeInfo *FSI = getCurFunction())\n if ((VDecl->getType().getObjCLifetime() == Qualifiers::OCL_Strong || VDecl->getType().isNonWeakInMRRWithObjCWeak(Context)) && !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Init->getBeginLoc()))"},{G,2213,"/// BuildDeclRefExpr - Build an expression that references a\n/// declaration that does not require a closure capture.\nDeclRefExpr *Sema::BuildDeclRefExpr(ValueDecl *D, QualType Ty, ExprValueKind VK, const DeclarationNameInfo &NameInfo, NestedNameSpecifierLoc NNS, NamedDecl *FoundD, SourceLocation TemplateKWLoc, const TemplateArgumentListInfo *TemplateArgs) {\n // ...\n if (getLangOpts().ObjCWeak && isa<VarDecl>(D) && Ty.getObjCLifetime() == Qualifiers::OCL_Weak && !isUnevaluatedContext() && !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, E->getBeginLoc()))"},{G,3049,"ExprResult Sema::BuildIvarRefExpr(Scope *S, SourceLocation Loc, ObjCIvarDecl *IV) {\n // ...\n if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {\n if (!isUnevaluatedContext() && !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, Loc))"},{G,14631,"// C99 6.5.16.1\nQualType Sema::CheckAssignmentOperands(Expr *LHSExpr, ExprResult &RHS, SourceLocation Loc, QualType CompoundType, BinaryOperatorKind Opc) {\n // ...\n if (CompoundType.isNull()) {\n // ...\n if (ConvTy == Compatible) {\n // ...\n if (LHSType.getObjCLifetime() == Qualifiers::OCL_Strong || LHSType.isNonWeakInMRRWithObjCWeak(Context)) {\n // ...\n if (!Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, RHS.get()->getBeginLoc()))"},{"clang/lib/Sema/SemaExprMember.cpp",1483,"/// Look up the given member of the given non-type-dependent\n/// expression. This can return in one of two ways:\n/// * If it returns a sentinel null-but-valid result, the caller will\n/// assume that lookup was performed and the results written into\n/// the provided structure. It will take over from there.\n/// * Otherwise, the returned expression will be produced in place of\n/// an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n // ...\n // Handle ivar access to Objective-C objects.\n if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {\n // ...\n if (IV->getType().getObjCLifetime() == Qualifiers::OCL_Weak) {\n if (!S.isUnevaluatedContext() && !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, MemberLoc))"},{ec,3389,"/// Build an Objective-C instance message expression.\n///\n/// This routine takes care of both normal instance messages and\n/// instance messages to the superclass instance.\n///\n/// \\param Receiver The expression that computes the object that will\n/// receive this message. This may be empty, in which case we are\n/// sending to the superclass instance and \\p SuperLoc must be a valid\n/// source location.\n///\n/// \\param ReceiverType The (static) type of the object receiving the\n/// message. When a \\p Receiver expression is provided, this is the\n/// same type as that expression. For a superclass instance send, this\n/// is a pointer to the type of the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass instance message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this instance message is invoking, if\n/// already known.\n///\n/// \\param LBracLoc The location of the opening square bracket \']\'.\n///\n/// \\param RBracLoc The location of the closing square bracket \']\'.\n///\n/// \\param ArgsIn The message arguments.\nExprResult Sema::BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n // ...\n if (getLangOpts().ObjCWeak) {\n if (!isImplicit && Method) {\n if (const ObjCPropertyDecl *Prop = Method->findPropertyDecl()) {\n // ...\n if (IsWeak && !isUnevaluatedContext() && !Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, LBracLoc))"},{"clang/lib/Sema/SemaPseudoObject.cpp",856,"/// @property-specific behavior for doing lvalue-to-rvalue conversion.\nExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {\n // ...\n // As a special case, if the method returns \'id\', try to get\n // a better type from the property.\n if (RefExpr->isExplicitProperty() && result.get()->isPRValue()) {\n // ...\n if (propType.getObjCLifetime() == Qualifiers::OCL_Weak && !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, RefExpr->getLocation()))"},{"clang/lib/Sema/SemaPseudoObject.cpp",975,"ExprResult ObjCPropertyOpBuilder::complete(Expr *SyntacticForm) {\n if (isWeakProperty() && !S.isUnevaluatedContext() && !S.Diags.isIgnored(diag::warn_arc_repeated_use_of_weak, SyntacticForm->getBeginLoc()))"}},
[l]={
["clang/test/SemaObjC/arc-repeated-weak.mm"]={"clang/test/SemaObjC/arc-repeated-weak.mm:23:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:58:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:77:7: warning: weak implicit property \'implicitProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:82:7: warning: weak implicit property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:93:7: warning: weak instance variable \'weakIvar\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:99:7: warning: weak variable \'a\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:104:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:115:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:119:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:122:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:129:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:135:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:140:7: warning: weak instance variable \'weakIvar\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:146:7: warning: weak variable \'a\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:169:9: warning: weak property \'weakProp\' is accessed multiple times in this block but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:212:8: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:219:10: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:226:10: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:233:10: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:240:10: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:248:10: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:257:9: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:274:9: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:282:9: warning: weak variable \'a\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:311:7: warning: weak property \'weakProp\' is accessed multiple times in this method but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:316:7: warning: weak instance variable \'weakIvar\' is accessed multiple times in this method but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:321:7: warning: weak property \'weakProp\' is accessed multiple times in this method but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:324:7: warning: weak property \'weakProp\' is accessed multiple times in this method but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:327:7: warning: weak instance variable \'weakIvar\' is accessed multiple times in this method but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:375:9: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:402:7: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]","clang/test/SemaObjC/arc-repeated-weak.mm:407:9: warning: weak property \'weakProp\' is accessed multiple times in this function but may be unpredictably set to nil; assign to a strong variable to keep the object alive [-Warc-repeated-use-of-weak]"}
}
},
["warn_arc_retain_cycle"]={
[j]={Rc,"arc-retain-cycles"},
[k]="arc-retain-cycles",
[g]="warn_arc_retain_cycle",
[b]="capturing %0 strongly in this block is likely to lead to a retain cycle",
[c]="capturing A strongly in this block is likely to lead to a retain cycle",
[d]=m,
[e]="capturing (.*?) strongly in this block is likely to lead to a retain cycle",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-retain\\-cycles[^\\]]*\\]",
[h]="ARC Retain Cycle",
[a]={"31168b077c36",1308178962,"Automatic Reference Counting.","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"},
[i]={{u,17473,"static void diagnoseRetainCycle(Sema &S, Expr *capturer, RetainCycleOwner &owner) {\n // ...\n S.Diag(capturer->getExprLoc(), diag::warn_arc_retain_cycle) << owner.Variable << capturer->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/warn-retain-cycle.m"]={"clang/test/SemaObjC/warn-retain-cycle.m:12:12: warning: capturing \'x\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:14:12: warning: capturing \'x\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:17:12: warning: capturing \'x\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:31:22: warning: capturing \'x\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:48:31: warning: capturing \'x\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:49:30: warning: capturing \'x\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:63:33: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:69:28: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:71:31: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:74:28: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:81:28: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:94:18: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:126:19: warning: capturing \'self\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:149:5: warning: capturing \'b1\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:154:5: warning: capturing \'b2\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:170:6: warning: capturing \'obj\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]","clang/test/SemaObjC/warn-retain-cycle.m:174:6: warning: capturing \'obj\' strongly in this block is likely to lead to a retain cycle [-Warc-retain-cycles]"}
}
},
["warn_arc_retained_assign"]={
[j]={Rc,ic},
[k]=ic,
[g]="warn_arc_retained_assign",
[b]="assigning retained object to %select{weak|unsafe_unretained}0 %select{property|variable}1; object will be released after assignment",
[c]={{nil,nil,{"assigning retained object to ",{"weak","unsafe_unretained"},tc,{"property",Kc},"; object will be released after assignment"}}},
[d]=m,
[e]="assigning retained object to (?:weak|unsafe_unretained) (?:property|variable); object will be released after assignment",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-unsafe\\-retained\\-assign[^\\]]*\\]",
[h]=oc,
[a]={"31168b077c36",1308178962,"Automatic Reference Counting.","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"},
[i]={{u,17749,"static bool checkUnsafeAssignObject(Sema &S, SourceLocation Loc, Qualifiers::ObjCLifetime LT, Expr *RHS, bool isProperty) {\n // Strip off any implicit cast added to get to the one ARC-specific.\n while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {\n if (cast->getCastKind() == CK_ARCConsumeObject) {\n S.Diag(Loc, diag::warn_arc_retained_assign) << (LT == Qualifiers::OCL_ExplicitNone) << (isProperty ? 0 : 1) << RHS->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/arc-unsafe-assigns.m"]={"clang/test/SemaObjC/arc-unsafe-assigns.m:25:21: warning: assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:27:21: warning: assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:30:14: warning: assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:31:14: warning: assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:39:14: warning: assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:40:14: warning: assigning retained object to unsafe_unretained variable; object will be released after assignment [-Warc-unsafe-retained-assign]"}
}
},
["warn_arc_retained_property_assign"]={
[j]={Rc,ic},
[k]=ic,
[g]="warn_arc_retained_property_assign",
[b]="assigning retained object to unsafe property; object will be released after assignment",
[c]="assigning retained object to unsafe property; object will be released after assignment",
[d]=m,
[e]="assigning retained object to unsafe property; object will be released after assignment",
[f]=" \\[(?:\\-Werror,)?\\-Warc\\-unsafe\\-retained\\-assign[^\\]]*\\]",
[h]=oc,
[a]={"5f98da0ea2bb",1308939934,"objc-arc: Check on a variety of unsafe assignment of retained ","objc-arc: Check on a variety of unsafe assignment of retained \nobjects. // rdar://9495837\n\nllvm-svn: 133806"},
[i]={{u,17827,"void Sema::checkUnsafeExprAssigns(SourceLocation Loc, Expr *LHS, Expr *RHS) {\n // ...\n if (PRE) {\n // ...\n if (Attributes & ObjCPropertyAttribute::kind_assign) {\n // ...\n while (ImplicitCastExpr *cast = dyn_cast<ImplicitCastExpr>(RHS)) {\n if (cast->getCastKind() == CK_ARCConsumeObject) {\n Diag(Loc, diag::warn_arc_retained_property_assign) << RHS->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/arc-unsafe-assigns.m"]={"clang/test/SemaObjC/arc-unsafe-assigns.m:24:20: warning: assigning retained object to unsafe property; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:26:20: warning: assigning retained object to unsafe property; object will be released after assignment [-Warc-unsafe-retained-assign]","clang/test/SemaObjC/arc-unsafe-assigns.m:36:17: warning: assigning retained object to unsafe property; object will be released after assignment [-Warc-unsafe-retained-assign]"}
}
},
["warn_arc_strong_pointer_objc_pointer"]={
[j]={"explicit-ownership-type"},
[k]="explicit-ownership-type",
[g]="warn_arc_strong_pointer_objc_pointer",
[b]="method parameter of type %0 with no explicit ownership",
[c]="method parameter of type A with no explicit ownership",
[d]=m,
[e]="method parameter of type (.*?) with no explicit ownership",
[f]=" \\[(?:\\-Werror,)?\\-Wexplicit\\-ownership\\-type[^\\]]*\\]",
[h]="ARC Restrictions",
[a]={"cd278ffa2856",1346370962,"objective-C ARC: under -Wexplicit-ownership-type diagnose those","objective-C ARC: under -Wexplicit-ownership-type diagnose those\nmethod parameter types which are reference to an objective-C\npointer to object with no explicit ownership. // rdar://10907090\n\nllvm-svn: 162959"},
[i]={{W,403,"/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible\n/// and user declared, in the method definition\'s AST.\nvoid Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {\n // ...\n // Introduce all of the other parameters into this scope.\n for (auto *Param : MDecl->parameters()) {\n if (!Param->isInvalidDecl() && getLangOpts().ObjCAutoRefCount && !HasExplicitOwnershipAttr(*this, Param))\n Diag(Param->getLocation(), diag::warn_arc_strong_pointer_objc_pointer) << Param->getType();"}},
[l]={
["clang/test/SemaObjCXX/arc-objc-lifetime.mm"]={"clang/test/SemaObjCXX/arc-objc-lifetime.mm:50:50: warning: method parameter of type \'NSObject<P> *__autoreleasing &\' with no explicit ownership [-Wexplicit-ownership-type]","clang/test/SemaObjCXX/arc-objc-lifetime.mm:50:77: warning: method parameter of type \'__autoreleasing id<P> &\' with no explicit ownership [-Wexplicit-ownership-type]","clang/test/SemaObjCXX/arc-objc-lifetime.mm:53:26: warning: method parameter of type \'NSObject *__autoreleasing *\' with no explicit ownership [-Wexplicit-ownership-type]","clang/test/SemaObjCXX/arc-objc-lifetime.mm:53:38: warning: method parameter of type \'__autoreleasing id *\' with no explicit ownership [-Wexplicit-ownership-type]","clang/test/SemaObjCXX/arc-objc-lifetime.mm:56:23: warning: method parameter of type \'__autoreleasing T &\' (aka \'void (^__autoreleasing &)()\') with no explicit ownership [-Wexplicit-ownership-type]"}
}
},
["warn_arcmt_nsalloc_realloc"]={
[g]="warn_arcmt_nsalloc_realloc",
[b]="[rewriter] call returns pointer to GC managed memory; it will become unmanaged in ARC",
[c]="[rewriter] call returns pointer to GC managed memory; it will become unmanaged in ARC",
[d]=m,
[e]="\\[rewriter\\] call returns pointer to GC managed memory; it will become unmanaged in ARC",
[f]=jb,
[h]=O,
[a]={"403a4f9b826d",1400539871,"Get ARCMT/GC-check-warn-nsalloc.m working","Get ARCMT/GC-check-warn-nsalloc.m working\n\nThe -no-ns-alloc-error migration option now causes the diagnostic to be ignored\ncompletely. If this isn\'t desired, the error can be downgraded to a warning\nusing the usual -Wno-error=arcmt-ns-alloc.\n\nNote that we can\'t use -verify right now on this test because\nVerifyDiagnosticConsumer gets confused by multiple SourceManager instances,\nwhich is presumably the reason it was XFAILed in the first place and why the\nregression wasn\'t detected. We\'ll grep instead for now.\n\nllvm-svn: 209172"},
[i]={{"clang/lib/ARCMigrate/ARCMT.cpp",319,"bool arcmt::checkForManualIssues(CompilerInvocation &origCI, const FrontendInputFile &Input, std::shared_ptr<PCHContainerOperations> PCHContainerOps, DiagnosticConsumer *DiagClient, bool emitPremigrationARCErrors, StringRef plistOut) {\n // ...\n if (!NoNSAllocReallocError)\n Diags->setSeverity(diag::warn_arcmt_nsalloc_realloc, diag::Severity::Error, SourceLocation());"},{"clang/lib/ARCMigrate/TransGCCalls.cpp",41,"class GCCollectableCallsChecker : public RecursiveASTVisitor<GCCollectableCallsChecker> {\n // ...\n bool VisitCallExpr(CallExpr *E) {\n // ...\n if (MigrateCtx.isGCOwnedNonObjC(E->getType())) {\n TA.report(E->getBeginLoc(), diag::warn_arcmt_nsalloc_realloc, E->getSourceRange());"}},
[l]={
["clang/test/ARCMT/GC-check-warn-nsalloc.m"]={"clang/test/ARCMT/GC-check-warn-nsalloc.m:10:3: warning: [rewriter] call returns pointer to GC managed memory; it will become unmanaged in ARC"}
}
},
["warn_argument_invalid_range"]={
[j]={"argument-outside-range"},
[k]="argument-outside-range",
[g]={{nil,F,"warn_argument_invalid_range"}},
[b]={{nil,F,"argument value %0 is outside the valid range [%1, %2]"}},
[c]={{nil,F,"argument value A is outside the valid range [B, C]"}},
[d]=zc,
[e]="argument value (.*?) is outside the valid range \\[(.*?), (.*?)\\]",
[f]=" \\[[^\\]]*\\-Wargument\\-outside\\-range[^\\]]*\\]",
[h]={{nil,F,n}},
[a]={"16e6bc23a12e",1529624769,"[x86] Teach the builtin argument range check to allow invalid ranges in","[x86] Teach the builtin argument range check to allow invalid ranges in\ndead code.\n\nThis is important for C++ templates that essentially compute the valid\ninput in a way that is constant and will cause all the invalid cases to\nbe dead code that is deleted. Code in the wild actually does this and\nGCC also accepts these kinds of patterns so it is important to support\nit.\n\nTo make this work, we provide a non-error path to diagnose these issues,\nand use a default-error warning instead. This keeps the relatively\nstrict handling but prevents nastiness like SFINAE on these errors. It\nalso allows us to safely use the system to diagnose this only when it\noccurs at runtime (in emitted code).\n\nEntertainingly, this required fixing the syntax in various other ways\nfor the x86 test because we never bothered to diagnose that the returns\nwere invalid.\n\nSince debugging these compile failures was super confusing, I\'ve also\nimproved the diagnostic to actually say what the value was. Most of the\nchecks I\'ve made ignore this to simplify maintenance, but I\'ve checked\nit in a few places to make sure the diagnsotic is working.\n\nDepends on D48462. Without that, we might actually crash some part of\nthe compiler after bypassing the error here.\n\nThanks to Richard, Ben Kramer, and especially Craig Topper for all the\nhelp here.\n\nDifferential Revision: https://reviews.llvm.org/D48464\n\nllvm-svn: 335309"},
[i]={{u,8815,"/// SemaBuiltinConstantArgRange - Handle a check if argument ArgNum of CallExpr\n/// TheCall is a constant expression in the range [Low, High].\nbool Sema::SemaBuiltinConstantArgRange(CallExpr *TheCall, int ArgNum, int Low, int High, bool RangeIsError) {\n // ...\n if (Result.getSExtValue() < Low || Result.getSExtValue() > High) {\n if (RangeIsError)\n // ...\n else\n // ...\n DiagRuntimeBehavior(TheCall->getBeginLoc(), TheCall, PDiag(diag::warn_argument_invalid_range) << toString(Result, 10) << Low << High << Arg->getSourceRange());"}},
[l]={
["clang/test/Sema/builtins-x86.c"]={"clang/test/Sema/builtins-x86.c:25:10: error: argument value 32 is outside the valid range [0, 31] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:29:10: error: argument value 32 is outside the valid range [0, 31] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:33:10: error: argument value 32 is outside the valid range [0, 31] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:37:10: error: argument value 32 is outside the valid range [0, 31] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:41:10: error: argument value 32 is outside the valid range [0, 31] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:45:10: error: argument value 32 is outside the valid range [0, 31] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:49:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:53:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:57:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:61:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:65:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:69:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:73:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:77:10: error: argument value 8 is outside the valid range [0, 7] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:114:3: error: argument value 1 is outside the valid range [2, 3] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:118:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:122:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:126:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:130:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:134:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:138:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:142:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:146:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:150:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:154:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:158:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:162:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:166:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:170:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:174:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:178:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:182:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]","clang/test/Sema/builtins-x86.c:186:10: error: argument value 1024 is outside the valid range [0, 255] [-Wargument-outside-range]"}
}
},
["warn_argument_undefined_behaviour"]={
[j]={"argument-undefined-behaviour"},
[k]="argument-undefined-behaviour",
[g]={{nil,z,"warn_argument_undefined_behaviour"}},
[b]={{nil,z,"argument value %0 will result in undefined behaviour"}},
[c]={{nil,z,"argument value A will result in undefined behaviour"}},
[d]=m,
[e]="argument value (.*?) will result in undefined behaviour",
[f]=" \\[(?:\\-Werror,)?\\-Wargument\\-undefined\\-behaviour[^\\]]*\\]",
[h]={{nil,z,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{u,4324,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n // ...\n case PPC::BI__builtin_ppc_addex: {\n // ...\n if (ArgValue != 0)\n Diag(TheCall->getBeginLoc(), diag::warn_argument_undefined_behaviour) << ArgValue;"}},
[l]={
["clang/test/CodeGen/PowerPC/builtins-ppc-xlcompat-pwr9-warning.c"]={"clang/test/CodeGen/PowerPC/builtins-ppc-xlcompat-pwr9-warning.c:9:19: warning: argument value 1 will result in undefined behaviour [-Wargument-undefined-behaviour]","clang/test/CodeGen/PowerPC/builtins-ppc-xlcompat-pwr9-warning.c:10:29: warning: argument value 3 will result in undefined behaviour [-Wargument-undefined-behaviour]"}
}
},
["warn_arith_conv_enum_float"]={
[j]={Bb,jc,"enum-float-conversion",Cb},
[k]="enum-float-conversion",
[g]={{nil,s,"warn_arith_conv_enum_float"}},
[b]={{nil,s,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 %select{floating-point|enumeration}1 type %2 %plural{2:with|4:from|:and}0 %select{enumeration|floating-point}1 type %3"}},
[c]={{nil,s,{{xb,wb,qb,ub,yb},tc,{"floating-point","enumeration"}," type C ",{"with","from","and"},tc,{"enumeration","floating-point"}," type D"}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) (?:floating\\-point|enumeration) type (.*?) (?:with|from|and) (?:enumeration|floating\\-point) type (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wenum\\-float\\-conversion[^\\]]*\\]",
[h]={{nil,s,ac}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1504,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n S.Diag(Loc, S.getLangOpts().CPlusPlus20 ? diag::warn_arith_conv_enum_float_cxx20 : diag::warn_arith_conv_enum_float) << LHS->getSourceRange() << RHS->getSourceRange() << (int)ACK << LEnum << L << R;"}},
[l]={
[yc]={"clang/test/CXX/expr/expr.arith.conv/p2.cpp:13:11: warning: arithmetic between enumeration type \'enum E1\' and floating-point type \'double\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:14:10: warning: arithmetic between floating-point type \'double\' and enumeration type \'enum E1\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:18:11: warning: arithmetic between enumeration type \'enum E1\' and floating-point type \'double\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:19:10: warning: arithmetic between floating-point type \'double\' and enumeration type \'enum E1\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:30:11: warning: comparison of enumeration type \'enum E1\' with floating-point type \'double\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:31:10: warning: comparison of floating-point type \'double\' with enumeration type \'enum E1\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:35:11: warning: comparison of enumeration type \'enum E1\' with floating-point type \'double\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:36:10: warning: comparison of floating-point type \'double\' with enumeration type \'enum E1\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:40:10: warning: conditional expression between enumeration type \'enum E1\' and floating-point type \'double\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:41:10: warning: conditional expression between floating-point type \'double\' and enumeration type \'enum E1\' [-Wenum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:51:10: warning: compound assignment of floating-point type \'double\' from enumeration type \'enum E1\' [-Wenum-float-conversion]"}
}
},
["warn_arith_conv_enum_float_cxx20"]={
[j]={Bb,eb,"deprecated-enum-float-conversion",jc,"enum-float-conversion",Cb},
[k]="deprecated-enum-float-conversion",
[g]={{nil,t,"warn_arith_conv_enum_float_cxx20"}},
[b]={{nil,t,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 %select{floating-point|enumeration}1 type %2 %plural{2:with|4:from|:and}0 %select{enumeration|floating-point}1 type %3 is deprecated"}},
[c]={{nil,t,{{xb,wb,qb,ub,yb},tc,{"floating-point","enumeration"}," type C ",{"with","from","and"},tc,{"enumeration","floating-point"}," type D is deprecated"}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) (?:floating\\-point|enumeration) type (.*?) (?:with|from|and) (?:enumeration|floating\\-point) type (.*?) is deprecated",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-enum\\-float\\-conversion[^\\]]*\\]",
[h]={{nil,t,Gb}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1503,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n S.Diag(Loc, S.getLangOpts().CPlusPlus20 ? diag::warn_arith_conv_enum_float_cxx20 : diag::warn_arith_conv_enum_float) << LHS->getSourceRange() << RHS->getSourceRange() << (int)ACK << LEnum << L << R;"}},
[l]={
[yc]={"clang/test/CXX/expr/expr.arith.conv/p2.cpp:13:11: warning: arithmetic between enumeration type \'enum E1\' and floating-point type \'double\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:14:10: warning: arithmetic between floating-point type \'double\' and enumeration type \'enum E1\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:18:11: warning: arithmetic between enumeration type \'enum E1\' and floating-point type \'double\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:19:10: warning: arithmetic between floating-point type \'double\' and enumeration type \'enum E1\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:30:11: warning: comparison of enumeration type \'enum E1\' with floating-point type \'double\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:31:10: warning: comparison of floating-point type \'double\' with enumeration type \'enum E1\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:35:11: warning: comparison of enumeration type \'enum E1\' with floating-point type \'double\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:36:10: warning: comparison of floating-point type \'double\' with enumeration type \'enum E1\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:40:10: warning: conditional expression between enumeration type \'enum E1\' and floating-point type \'double\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:41:10: warning: conditional expression between floating-point type \'double\' and enumeration type \'enum E1\' is deprecated [-Wdeprecated-enum-float-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:51:10: warning: compound assignment of floating-point type \'double\' from enumeration type \'enum E1\' is deprecated [-Wdeprecated-enum-float-conversion]"}
}
},
["warn_arith_conv_mixed_anon_enum_types"]={
[j]={"anon-enum-enum-conversion"},
[k]="anon-enum-enum-conversion",
[g]={{nil,s,"warn_arith_conv_mixed_anon_enum_types"}},
[b]={{nil,s,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2"}},
[c]={{nil,s,{{xb,wb,qb,ub,yb},Ob,{Nb,r}}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wanon\\-enum\\-enum\\-conversion[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1517,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20 : diag::warn_arith_conv_mixed_anon_enum_types;"}}
},
["warn_arith_conv_mixed_anon_enum_types_cxx20"]={
[j]={"anon-enum-enum-conversion",eb,"deprecated-anon-enum-enum-conversion"},
[k]="deprecated-anon-enum-enum-conversion",
[g]={{nil,t,"warn_arith_conv_mixed_anon_enum_types_cxx20"}},
[b]={{nil,t,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2 is deprecated"}},
[c]={{nil,t,{{xb,wb,qb,ub,yb},Ob,{Nb,r}," is deprecated"}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|) is deprecated",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-anon\\-enum\\-enum\\-conversion[^\\]]*\\]",
[h]={{nil,t,Gb}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1516,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_arith_conv_mixed_anon_enum_types_cxx20 : diag::warn_arith_conv_mixed_anon_enum_types;"}}
},
["warn_arith_conv_mixed_enum_types"]={
[j]={Bb,jc,"enum-enum-conversion",Cb},
[k]="enum-enum-conversion",
[g]={{nil,s,"warn_arith_conv_mixed_enum_types"}},
[b]={{nil,s,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2"}},
[c]={{nil,s,{{xb,wb,qb,ub,yb},Ob,{Nb,r}}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wenum\\-enum\\-conversion[^\\]]*\\]",
[h]={{nil,s,ac}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1533,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n } else if (ACK == Sema::ACK_Conditional) {\n // ...\n } else if (ACK == Sema::ACK_Comparison) {\n // ...\n } else {\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_arith_conv_mixed_enum_types_cxx20 : diag::warn_arith_conv_mixed_enum_types;"}},
[l]={
[yc]={"clang/test/CXX/expr/expr.arith.conv/p2.cpp:12:11: warning: arithmetic between different enumeration types (\'enum E1\' and \'enum E2\') [-Wenum-enum-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:17:11: warning: arithmetic between different enumeration types (\'enum E1\' and \'enum E2\') [-Wenum-enum-conversion]"}
}
},
["warn_arith_conv_mixed_enum_types_cxx20"]={
[j]={Bb,eb,"deprecated-enum-enum-conversion",jc,"enum-enum-conversion",Cb},
[k]="deprecated-enum-enum-conversion",
[g]={{nil,t,"warn_arith_conv_mixed_enum_types_cxx20"}},
[b]={{nil,t,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2 is deprecated"}},
[c]={{nil,t,{{xb,wb,qb,ub,yb},Ob,{Nb,r}," is deprecated"}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|) is deprecated",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-enum\\-enum\\-conversion[^\\]]*\\]",
[h]={{nil,t,Gb}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1532,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n } else if (ACK == Sema::ACK_Conditional) {\n // ...\n } else if (ACK == Sema::ACK_Comparison) {\n // ...\n } else {\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_arith_conv_mixed_enum_types_cxx20 : diag::warn_arith_conv_mixed_enum_types;"}},
[l]={
[yc]={"clang/test/CXX/expr/expr.arith.conv/p2.cpp:12:11: warning: arithmetic between different enumeration types (\'enum E1\' and \'enum E2\') is deprecated [-Wdeprecated-enum-enum-conversion]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:17:11: warning: arithmetic between different enumeration types (\'enum E1\' and \'enum E2\') is deprecated [-Wdeprecated-enum-enum-conversion]"}
}
},
["warn_arm_interrupt_calling_convention"]={
[j]={r,P,Nc},
[k]=Nc,
[g]={{nil,E,"warn_arm_interrupt_calling_convention"}},
[b]={{nil,E,"call to function without interrupt attribute could clobber interruptee\'s VFP registers"}},
[c]={{nil,E,"call to function without interrupt attribute could clobber interruptee\'s VFP registers"}},
[d]=m,
[e]="call to function without interrupt attribute could clobber interruptee\'s VFP registers",
[f]=" \\[(?:\\-Werror,)?\\-Wextra[^\\]]*\\]",
[h]={{nil,E,n}},
[a]={"8277c41a899b",1484753471,"Warn when calling a non interrupt function from an interrupt on ARM","Warn when calling a non interrupt function from an interrupt on ARM\n\nThe idea for this originated from a really tricky bug: ISRs on ARM don\'t\nautomatically save off the VFP regs, so if say, memcpy gets interrupted and the\nISR itself calls memcpy, the regs are left clobbered when the ISR is done.\n\nhttps://reviews.llvm.org/D28820\n\nllvm-svn: 292375"},
[i]={{G,7358,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy. The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n // ...\n // Interrupt handlers don\'t save off the VFP regs automatically on ARM,\n // so there\'s some risk when calling out to non-interrupt handler functions\n // that the callee might not preserve them. This is easy to diagnose here,\n // but can be very challenging to debug.\n // Likewise, X86 interrupt handlers may only call routines with attribute\n // no_caller_saved_registers since there is no efficient way to\n // save and restore the non-GPR state.\n if (auto *Caller = getCurFunctionDecl()) {\n if (Caller->hasAttr<ARMInterruptAttr>()) {\n // ...\n if (VFP && (!FDecl || !FDecl->hasAttr<ARMInterruptAttr>())) {\n Diag(Fn->getExprLoc(), diag::warn_arm_interrupt_calling_convention);"}},
[l]={
["clang/test/Sema/arm-interrupt-attr.c"]={"clang/test/Sema/arm-interrupt-attr.c:34:3: warning: call to function without interrupt attribute could clobber interruptee\'s VFP registers [-Wextra]","clang/test/Sema/arm-interrupt-attr.c:40:3: warning: call to function without interrupt attribute could clobber interruptee\'s VFP registers [-Wextra]"}
}
},
["warn_array_index_exceeds_bounds"]={
[j]={gc},
[k]=gc,
[g]="warn_array_index_exceeds_bounds",
[b]={{nil,v,"array index %0 is past the end of the array (that has type %1%select{|, cast to %3}2)"},{D,nil,"array index %0 is past the end of the array (which contains %1 element%s2)"}},
[c]={{nil,v,{"array index A is past the end of the array (that has type B",{r,", cast to D"},")"}},{D,nil,"array index A is past the end of the array (which contains B elementC)"}},
[d]=m,
[e]="array index (.*?) is past the end of the array \\(that has type (.*?)(?:|, cast to (.*?))\\)",
[f]=" \\[(?:\\-Werror,)?\\-Warray\\-bounds[^\\]]*\\]",
[h]=n,
[a]={"108b2d56bf41",1297828904,"Tweak -Warray-bounds diagnostics based on feedback from Chandler.","Tweak -Warray-bounds diagnostics based on feedback from Chandler.\n\nllvm-svn: 125649"},
[i]={{u,17168,"void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, const ArraySubscriptExpr *ASE, bool AllowOnePastEnd, bool IndexNegated) {\n // ...\n if (index.isUnsigned() || !index.isNegative()) {\n // ...\n unsigned DiagID = ASE ? diag::warn_array_index_exceeds_bounds : diag::warn_ptr_arith_exceeds_bounds;"}},
[l]={
["clang/test/SemaCXX/array-bounds-system-header.cpp"]={"clang/test/SemaCXX/array-bounds-system-header.cpp:6:15: warning: array index 3 is past the end of the array (that has type \'char[3]\') [-Warray-bounds]","clang/test/SemaCXX/array-bounds-system-header.cpp:8:7: warning: array index 3 is past the end of the array (that has type \'char[3]\') [-Warray-bounds]"}
}
},
["warn_array_index_exceeds_max_addressable_bounds"]={
[j]={gc},
[k]=gc,
[g]={{nil,w,"warn_array_index_exceeds_max_addressable_bounds"}},
[b]={{nil,w,"array index %0 refers past the last possible element for an array in %1-bit address space containing %2-bit (%3-byte) elements (max possible %4 element%s5)"}},
[c]={{nil,w,"array index A refers past the last possible element for an array in B-bit address space containing C-bit (D-byte) elements (max possible E elementF)"}},
[d]=m,
[e]="array index (.*?) refers past the last possible element for an array in (.*?)\\-bit address space containing (.*?)\\-bit \\((.*?)\\-byte\\) elements \\(max possible (.*?) element(.*?)\\)",
[f]=" \\[(?:\\-Werror,)?\\-Warray\\-bounds[^\\]]*\\]",
[h]={{nil,w,n}},
[a]={"da55e9ba1273",1600125132,"[Sema] Address-space sensitive index check for unbounded arrays","[Sema] Address-space sensitive index check for unbounded arrays\n\nCheck applied to unbounded (incomplete) arrays and pointers\nto spot cases where the computed address is beyond the\nlargest possible addressable extent of the array, based\non the address space in which the array is delcared, or\nwhich the pointer refers to.\n\nCheck helps to avoid cases of nonsense pointer math and\narray indexing which could lead to linker failures or\nruntime exceptions. Of particular interest when building\nfor embedded systems with small address spaces.\n\nReviewed By: aaron.ballman\n\nDifferential Revision: https://reviews.llvm.org/D86796"},
[i]={{u,17078,"void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, const ArraySubscriptExpr *ASE, bool AllowOnePastEnd, bool IndexNegated) {\n // ...\n if (IsUnboundedArray) {\n // ...\n if (index.isUnsigned() || !index.isNegative()) {\n // ...\n unsigned DiagID = ASE ? diag::warn_array_index_exceeds_max_addressable_bounds : diag::warn_ptr_arith_exceeds_max_addressable_bounds;"}},
[l]={
["clang/test/Sema/const-eval.c"]={"clang/test/Sema/const-eval.c:148:20: warning: array index 18446744073709551615 refers past the last possible element for an array in 64-bit address space containing 64-bit (8-byte) elements (max possible 2305843009213693952 elements) [-Warray-bounds]"}
}
},
["warn_array_index_precedes_bounds"]={
[j]={gc},
[k]=gc,
[g]="warn_array_index_precedes_bounds",
[b]="array index %0 is before the beginning of the array",
[c]="array index A is before the beginning of the array",
[d]=m,
[e]="array index (.*?) is before the beginning of the array",
[f]=" \\[(?:\\-Werror,)?\\-Warray\\-bounds[^\\]]*\\]",
[h]=n,
[a]={"108b2d56bf41",1297828904,"Tweak -Warray-bounds diagnostics based on feedback from Chandler.","Tweak -Warray-bounds diagnostics based on feedback from Chandler.\n\nllvm-svn: 125649"},
[i]={{u,17178,"void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, const ArraySubscriptExpr *ASE, bool AllowOnePastEnd, bool IndexNegated) {\n // ...\n if (index.isUnsigned() || !index.isNegative()) {\n // ...\n } else {\n unsigned DiagID = diag::warn_array_index_precedes_bounds;"}},
[l]={
["clang/test/SemaCXX/array-bounds.cpp"]={"clang/test/SemaCXX/array-bounds.cpp:16:10: warning: array index -1 is before the beginning of the array [-Warray-bounds]","clang/test/SemaCXX/array-bounds.cpp:300:41: warning: array index -1 is before the beginning of the array [-Warray-bounds]","clang/test/SemaCXX/array-bounds.cpp:307:14: warning: array index -1 is before the beginning of the array [-Warray-bounds]","clang/test/SemaCXX/array-bounds.cpp:307:14: warning: array index -1 is before the beginning of the array [-Warray-bounds]"}
}
},
["warn_asm_label_on_auto_decl"]={
[g]="warn_asm_label_on_auto_decl",
[b]="ignored asm label \'%0\' on automatic variable",
[c]="ignored asm label \'A\' on automatic variable",
[d]=m,
[e]="ignored asm label \'(.*?)\' on automatic variable",
[f]=jb,
[h]="Inline Assembly Issue",
[a]={"133922318641",1294759012,"Added warning about invalid register specification for local variables.","Added warning about invalid register specification for local variables.\n\nllvm-svn: 123236"},
[i]={{H,7939,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n // ...\n // Handle GNU asm-label extension (encoded as an attribute).\n if (Expr *E = (Expr *)D.getAsmLabel()) {\n // ...\n if (S->getFnParent() != nullptr) {\n // ...\n case SC_None:\n case SC_Auto:\n Diag(E->getExprLoc(), diag::warn_asm_label_on_auto_decl) << Label;"}},
[l]={
["clang/test/Sema/asm.c"]={"clang/test/Sema/asm.c:112:14: warning: ignored asm label \'a_asm\' on automatic variable","clang/test/Sema/asm.c:113:20: warning: ignored asm label \'aa_asm\' on automatic variable"}
}
},
["warn_asm_mismatched_size_modifier"]={
[j]={"asm","asm-operand-widths"},
[k]="asm-operand-widths",
[g]="warn_asm_mismatched_size_modifier",
[b]="value size does not match register size specified by the constraint and modifier",
[c]="value size does not match register size specified by the constraint and modifier",
[d]=m,
[e]="value size does not match register size specified by the constraint and modifier",
[f]=" \\[(?:\\-Werror,)?\\-Wasm\\-operand\\-widths[^\\]]*\\]",
[h]="Inline Assembly Issue",
[a]={"9d1ee1175de3",1351207728,"Recommit Eric\'s code to validate ASM string\'s constraints and modifiers.","Recommit Eric\'s code to validate ASM string\'s constraints and modifiers.\n\nThis code checks the ASM string to see if the output size is able to fit within\nthe variable specified as the output. For instance, scalar-to-vector conversions\nmay not really work. It\'s on by default, but can be turned off with a flag if\nyou think you know what you\'re doing.\n\nThis is placed under a flag (\'-Wasm-operand-widths\') and flag group (\'-Wasm\').\n\n<rdar://problem/12284092>\n\nllvm-svn: 166737"},
[i]={{"clang/lib/Sema/SemaStmtAsm.cpp",550,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n // ...\n // Validate constraints and modifiers.\n for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {\n // ...\n if (!Context.getTargetInfo().validateConstraintModifier(Literal->getString(), Piece.getModifier(), Size, SuggestedModifier)) {\n targetDiag(Exprs[ConstraintIdx]->getBeginLoc(), diag::warn_asm_mismatched_size_modifier);"}},
[l]={
["clang/test/Sema/arm64-inline-asm.c"]={"clang/test/Sema/arm64-inline-asm.c:8:33: warning: value size does not match register size specified by the constraint and modifier [-Wasm-operand-widths]"}
}
},
["warn_assume_aligned_too_great"]={
[j]={"builtin-assume-aligned-alignment"},
[k]="builtin-assume-aligned-alignment",
[g]={{nil,s,"warn_assume_aligned_too_great"}},
[b]={{nil,s,"requested alignment must be %0 bytes or smaller; maximum alignment assumed"}},
[c]={{nil,s,"requested alignment must be A bytes or smaller; maximum alignment assumed"}},
[d]=m,
[e]="requested alignment must be (.*?) bytes or smaller; maximum alignment assumed",
[f]=" \\[(?:\\-Werror,)?\\-Wbuiltin\\-assume\\-aligned\\-alignment[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"7c11da0cfd33",1567434909,"[clang] New __attribute__((__clang_arm_mve_alias)).","[clang] New __attribute__((__clang_arm_mve_alias)).\n\nThis allows you to declare a function with a name of your choice (say\n`foo`), but have clang treat it as if it were a builtin function (say\n`__builtin_foo`), by writing\n\n static __inline__ __attribute__((__clang_arm_mve_alias(__builtin_foo)))\n int foo(args);\n\nI\'m intending to use this for the ACLE intrinsics for MVE, which have\nto be polymorphic on their argument types and also need to be\nimplemented by builtins. To avoid having to implement the polymorphism\nwith several layers of nested _Generic and make error reporting\nhideous, I want to make all the user-facing intrinsics correspond\ndirectly to clang builtins, so that after clang resolves\n__attribute__((overloadable)) polymorphism it\'s already holding the\nright BuiltinID for the intrinsic it selected.\n\nHowever, this commit itself just introduces the new attribute, and\ndoesn\'t use it for anything.\n\nTo avoid unanticipated side effects if this attribute is used to make\naliases to other builtins, there\'s a restriction mechanism: only\n(BuiltinID, alias) pairs that are approved by the function\nArmMveAliasValid() will be permitted. At present, that function\ndoesn\'t permit anything, because the Tablegen that will generate its\nlist of valid pairs isn\'t yet implemented. So the only test of this\nfacility is one that checks that an unapproved builtin _can\'t_ be\naliased.\n\nReviewers: dmgreen, miyuki, ostannard\n\nSubscribers: cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D67159"},
[i]={{u,6745,"/// Handles the checks for format strings, non-POD arguments to vararg\n/// functions, NULL arguments passed to non-NULL parameters, and diagnose_if\n/// attributes.\nvoid Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto, const Expr *ThisArg, ArrayRef<const Expr *> Args, bool IsMemberFunction, SourceLocation Loc, SourceRange Range, VariadicCallType CallType) {\n // ...\n if (FDecl && FDecl->hasAttr<AllocAlignAttr>()) {\n // ...\n if (!Arg->isValueDependent()) {\n // ...\n if (Arg->EvaluateAsInt(Align, Context)) {\n // ...\n if (I > Sema::MaximumAlignment)\n Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great) << Arg->getSourceRange() << Sema::MaximumAlignment;"},{u,8678,"/// Handle __builtin_assume_aligned. This is declared\n/// as (const void*, size_t, ...) and can take one optional constant int arg.\nbool Sema::SemaBuiltinAssumeAligned(CallExpr *TheCall) {\n // ...\n // We can\'t check the value of a dependent argument.\n if (!SecondArg->isValueDependent()) {\n // ...\n if (Result > Sema::MaximumAlignment)\n Diag(TheCall->getBeginLoc(), diag::warn_assume_aligned_too_great) << SecondArg->getSourceRange() << Sema::MaximumAlignment;"},{o,1717,"void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE) {\n // ...\n if (!E->isValueDependent()) {\n // ...\n if (*I > Sema::MaximumAlignment)\n Diag(CI.getLoc(), diag::warn_assume_aligned_too_great) << CI.getRange() << Sema::MaximumAlignment;"}},
[l]={
["clang/test/Sema/alloc-align-attr.c"]={"clang/test/Sema/alloc-align-attr.c:30:31: warning: requested alignment must be 4294967296 bytes or smaller; maximum alignment assumed [-Wbuiltin-assume-aligned-alignment]"}
}
},
["warn_assume_attribute_string_unknown"]={
[j]={"unknown-assumption"},
[k]="unknown-assumption",
[g]={{nil,p,"warn_assume_attribute_string_unknown"}},
[b]={{nil,p,"unknown assumption string \'%0\'; attribute is potentially ignored"}},
[c]={{nil,p,"unknown assumption string \'A\'; attribute is potentially ignored"}},
[d]=m,
[e]="unknown assumption string \'(.*?)\'; attribute is potentially ignored",
[f]=" \\[(?:\\-Werror,)?\\-Wunknown\\-assumption[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{o,1784,"/// Check if \\p AssumptionStr is a known assumption and warn if not.\nstatic void checkAssumptionAttr(Sema &S, SourceLocation Loc, StringRef AssumptionStr) {\n // ...\n if (!Suggestion.empty())\n // ...\n else\n S.Diag(Loc, diag::warn_assume_attribute_string_unknown) << AssumptionStr;"}},
[l]={
["clang/test/Sema/attr-assume.c"]={"clang/test/Sema/attr-assume.c:6:37: warning: unknown assumption string \'QQQQ\'; attribute is potentially ignored [-Wunknown-assumption]"}
}
},
["warn_assume_attribute_string_unknown_suggested"]={
[j]={"misspelled-assumption"},
[k]="misspelled-assumption",
[g]={{nil,p,"warn_assume_attribute_string_unknown_suggested"}},
[b]={{nil,p,"unknown assumption string \'%0\' may be misspelled; attribute is potentially ignored, did you mean \'%1\'?"}},
[c]={{nil,p,"unknown assumption string \'A\' may be misspelled; attribute is potentially ignored, did you mean \'B\'?"}},
[d]=m,
[e]="unknown assumption string \'(.*?)\' may be misspelled; attribute is potentially ignored, did you mean \'(.*?)\'\\?",
[f]=" \\[(?:\\-Werror,)?\\-Wmisspelled\\-assumption[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{o,1781,"/// Check if \\p AssumptionStr is a known assumption and warn if not.\nstatic void checkAssumptionAttr(Sema &S, SourceLocation Loc, StringRef AssumptionStr) {\n // ...\n if (!Suggestion.empty())\n S.Diag(Loc, diag::warn_assume_attribute_string_unknown_suggested) << AssumptionStr << Suggestion;"}},
[l]={
["clang/test/Sema/attr-assume.c"]={"clang/test/Sema/attr-assume.c:8:37: warning: unknown assumption string \'omp_noopenmp\' may be misspelled; attribute is potentially ignored, did you mean \'omp_no_openmp\'? [-Wmisspelled-assumption]","clang/test/Sema/attr-assume.c:9:37: warning: unknown assumption string \'omp_no_openmp_routine\' may be misspelled; attribute is potentially ignored, did you mean \'omp_no_openmp_routines\'? [-Wmisspelled-assumption]","clang/test/Sema/attr-assume.c:10:37: warning: unknown assumption string \'omp_no_openmp1\' may be misspelled; attribute is potentially ignored, did you mean \'omp_no_openmp\'? [-Wmisspelled-assumption]"}
}
},
["warn_assume_side_effects"]={
[j]={"assume"},
[k]="assume",
[g]="warn_assume_side_effects",
[b]="the argument to %0 has side effects that will be discarded",
[c]="the argument to A has side effects that will be discarded",
[d]=m,
[e]="the argument to (.*?) has side effects that will be discarded",
[f]=" \\[(?:\\-Werror,)?\\-Wassume[^\\]]*\\]",
[h]=n,
[a]={"f04173358502",1405607155,"Add an __assume side-effects warning","Add an __assume side-effects warning\n\nIn MS-compatibility mode, we support the __assume builtin. The __assume builtin\ndoes not evaluate its arguments, and we should issue a warning if __assume is\nprovided with an argument with side effects (because these effects will be\ndiscarded).\n\nThis is similar in spirit to the warnings issued by other compilers (Intel\nDiagnostic 2261, MS Compiler Warning C4557).\n\nllvm-svn: 213266"},
[i]={{u,8605,"/// SemaBuiltinAssume - Handle __assume (MS Extension).\n// __assume does not evaluate its arguments, and should warn if its argument\n// has side effects.\nbool Sema::SemaBuiltinAssume(CallExpr *TheCall) {\n // ...\n if (Arg->HasSideEffects(Context))\n Diag(Arg->getBeginLoc(), diag::warn_assume_side_effects) << Arg->getSourceRange() << cast<FunctionDecl>(TheCall->getCalleeDecl())->getIdentifier();"}},
[l]={
["clang/test/Sema/stmtexprs.c"]={"clang/test/Sema/stmtexprs.c:8:21: warning: the argument to \'__builtin_assume\' has side effects that will be discarded [-Wassume]"}
}
},
["warn_at_available_unchecked_use"]={
[j]={"unsupported-availability-guard"},
[k]="unsupported-availability-guard",
[g]={{nil,E,"warn_at_available_unchecked_use"}},
[b]={{nil,E,"%select{@available|__builtin_available}0 does not guard availability here; use if (%select{@available|__builtin_available}0) instead"}},
[c]={{nil,E,{{"@available","__builtin_available"}," does not guard availability here; use if (",{"@available","__builtin_available"},") instead"}}},
[d]=m,
[e]="(?:@available|__builtin_available) does not guard availability here; use if \\((?:@available|__builtin_available)\\) instead",
[f]=" \\[(?:\\-Werror,)?\\-Wunsupported\\-availability\\-guard[^\\]]*\\]",
[h]={{nil,E,n}},
[a]={"0a484baa8516",1495638929,"Warn about uses of `@available` that can\'t suppress the","Warn about uses of `@available` that can\'t suppress the\n-Wunguarded-availability warnings\n\nrdar://32306520\n\nDifferential Revision: https://reviews.llvm.org/D33450\n\nllvm-svn: 303761"},
[i]={{"clang/lib/Sema/SemaAvailability.cpp",730,"/// This class implements -Wunguarded-availability.\n///\n/// This is done with a traversal of the AST of a function that makes reference\n/// to a partially available declaration. Whenever we encounter an \\c if of the\n/// form: \\c if(@available(...)), we use the version from the condition to visit\n/// the then statement.\nclass DiagnoseUnguardedAvailability : public RecursiveASTVisitor<DiagnoseUnguardedAvailability> {\n // ...\n bool VisitObjCAvailabilityCheckExpr(ObjCAvailabilityCheckExpr *E) {\n SemaRef.Diag(E->getBeginLoc(), diag::warn_at_available_unchecked_use) << (!SemaRef.getLangOpts().ObjC);"}},
[l]={
["clang/test/SemaObjC/unguarded-availability.m"]={"clang/test/SemaObjC/unguarded-availability.m:169:7: warning: @available does not guard availability here; use if (@available) instead [-Wunsupported-availability-guard]","clang/test/SemaObjC/unguarded-availability.m:175:22: warning: @available does not guard availability here; use if (@available) instead [-Wunsupported-availability-guard]"}
}
},
["warn_atimport_in_framework_header"]={
[j]={"atimport-in-framework-header"},
[k]="atimport-in-framework-header",
[g]={{nil,F,"warn_atimport_in_framework_header"}},
[b]={{nil,F,"use of \'@import\' in framework header is discouraged, including this header requires -fmodules"}},
[c]={{nil,F,"use of \'@import\' in framework header is discouraged, including this header requires -fmodules"}},
[d]=m,
[e]="use of \'@import\' in framework header is discouraged, including this header requires \\-fmodules",
[f]=" \\[(?:\\-Werror,)?\\-Watimport\\-in\\-framework\\-header[^\\]]*\\]",
[h]={{nil,F,db}},
[a]={"03e0d2d82be7",1530131376,"[Modules][ObjC] Warn on the use of \'@import\' in framework headers","[Modules][ObjC] Warn on the use of \'@import\' in framework headers\n\nUsing @import in framework headers inhibit the use of such headers\nwhen not using modules, this is specially bad for headers that end\nup in the SDK (or any other system framework). Add a warning to give\nusers some indication that this is discouraged.\n\nrdar://problem/39192894\n\nllvm-svn: 335780"},
[i]={{"clang/lib/Parse/Parser.cpp",2606,"/// Parse a module import declaration. This is essentially the same for\n/// Objective-C and C++20 except for the leading \'@\' (in ObjC) and the\n/// trailing optional attributes (in C++).\n///\n/// [ObjC] @import declaration:\n/// \'@\' \'import\' module-name \';\'\n/// [ModTS] module-import-declaration:\n/// \'import\' module-name attribute-specifier-seq[opt] \';\'\n/// [C++20] module-import-declaration:\n/// \'export\'[opt] \'import\' module-name\n/// attribute-specifier-seq[opt] \';\'\n/// \'export\'[opt] \'import\' module-partition\n/// attribute-specifier-seq[opt] \';\'\n/// \'export\'[opt] \'import\' header-name\n/// attribute-specifier-seq[opt] \';\'\nDecl *Parser::ParseModuleImport(SourceLocation AtLoc, Sema::ModuleImportState &ImportState) {\n // ...\n // Using \'@import\' in framework headers requires modules to be enabled so that\n // the header is parseable. Emit a warning to make the user aware.\n if (IsObjCAtImport && AtLoc.isValid()) {\n // ...\n if (FE && llvm::sys::path::parent_path(FE->getDir().getName()).endswith(\".framework\"))\n Diags.Report(AtLoc, diag::warn_atimport_in_framework_header);"}},
[l]={
["clang/test/Modules/self-import-header.m"]={"clang/test/Modules/Inputs/self-import-header/af.framework/Headers/a1.h:1:1: warning: use of \'@import\' in framework header is discouraged, including this header requires -fmodules [-Watimport-in-framework-header]"}
}
},
["warn_atl_uuid_deprecated"]={
[j]={eb,"deprecated-declarations"},
[k]="deprecated-declarations",
[g]={{nil,E,"warn_atl_uuid_deprecated"}},
[b]={{nil,E,"specifying \'uuid\' as an ATL attribute is deprecated; use __declspec instead"}},
[c]={{nil,E,"specifying \'uuid\' as an ATL attribute is deprecated; use __declspec instead"}},
[d]=m,
[e]="specifying \'uuid\' as an ATL attribute is deprecated; use __declspec instead",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-declarations[^\\]]*\\]",
[h]={{nil,E,Gb}},
[a]={"469891e7a293",1494003956,"Warn that the [] spelling of uuid(...) is deprecated.","Warn that the [] spelling of uuid(...) is deprecated.\n\nhttps://reviews.llvm.org/D32879\n\nllvm-svn: 302255"},
[i]={{o,7040,"static void handleUuidAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n // FIXME: It\'d be nice to also emit a fixit removing uuid(...) (and, if it\'s\n // the only thing in the [] list, the [] too), and add an insertion of\n // __declspec(uuid(...)). But sadly, neither the SourceLocs of the commas\n // separating attributes nor of the [ and the ] are in the AST.\n // Cf \"SourceLocations of attribute list delimiters - [[ ... , ... ]] etc\"\n // on cfe-dev.\n if (AL.isMicrosoftAttribute()) // Check for [uuid(...)] spelling.\n S.Diag(AL.getLoc(), diag::warn_atl_uuid_deprecated);"}},
[l]={
["clang/test/Parser/MicrosoftExtensions.cpp"]={"clang/test/Parser/MicrosoftExtensions.cpp:71:2: warning: specifying \'uuid\' as an ATL attribute is deprecated; use __declspec instead [-Wdeprecated-declarations]"}
}
},
["warn_atomic_implicit_seq_cst"]={
[j]={"atomic-implicit-seq-cst"},
[k]="atomic-implicit-seq-cst",
[g]={{nil,V,"warn_atomic_implicit_seq_cst"}},
[b]={{nil,V,"implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary"}},
[c]={{nil,V,"implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary"}},
[d]=m,
[e]="implicit use of sequentially\\-consistent atomic may incur stronger memory barriers than necessary",
[f]=" \\[(?:\\-Werror,)?\\-Watomic\\-implicit\\-seq\\-cst[^\\]]*\\]",
[h]={{nil,V,n}},
[a]={"e77b48b07840",1536612176,"Implement -Watomic-implicit-seq-cst","Implement -Watomic-implicit-seq-cst\n\nSummary:\n_Atomic and __sync_* operations are implicitly sequentially-consistent. Some\ncodebases want to force explicit usage of memory order instead. This warning\nallows them to know where implicit sequentially-consistent memory order is used.\nThe warning isn\'t on by default because _Atomic was purposefully designed to\nhave seq_cst as the default: the idea was that it\'s the right thing to use most\nof the time. This warning allows developers who disagree to enforce explicit\nusage instead.\n\nA follow-up patch will take care of C++\'s std::atomic. It\'ll be different enough\nfrom this patch that I think it should be separate: for C++ the atomic\noperations all have a memory order parameter (or two), but it\'s defaulted. I\nbelieve this warning should trigger when the default is used, but not when\nseq_cst is used explicitly (or implicitly as the failure order for cmpxchg).\n\n<rdar://problem/28172966>\n\nReviewers: rjmccall\n\nSubscribers: dexonsmith, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D51084\n\nllvm-svn: 341860"},
[i]={{u,2356,"ExprResult Sema::CheckBuiltinFunctionCall(FunctionDecl *FDecl, unsigned BuiltinID, CallExpr *TheCall) {\n // ...\n case Builtin::BI__sync_synchronize:\n Diag(TheCall->getBeginLoc(), diag::warn_atomic_implicit_seq_cst) << TheCall->getCallee()->getSourceRange();"},{u,7817,"/// We have a call to a function like __sync_fetch_and_add, which is an\n/// overloaded function based on the pointer type of its first argument.\n/// The main BuildCallExpr routines have already promoted the types of\n/// arguments because all of these calls are prototyped as void(...).\n///\n/// This function goes through and does final semantic checking for these\n/// builtins, as well as generating any warnings.\nExprResult Sema::SemaBuiltinAtomicOverloaded(ExprResult TheCallResult) {\n // ...\n Diag(TheCall->getEndLoc(), diag::warn_atomic_implicit_seq_cst) << Callee->getSourceRange();"},{u,14185,"/// Analyze the given simple or compound assignment for warning-worthy\n/// operations.\nstatic void AnalyzeAssignment(Sema &S, BinaryOperator *E) {\n // ...\n // Diagnose implicitly sequentially-consistent atomic assignment.\n if (E->getLHS()->getType()->isAtomicType())\n S.Diag(E->getRHS()->getBeginLoc(), diag::warn_atomic_implicit_seq_cst);"},{u,14356,"/// Analyze the given compound assignment for the possible losing of\n/// floating-point precision.\nstatic void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) {\n // ...\n if (E->getLHS()->getType()->isAtomicType())\n S.Diag(E->getOperatorLoc(), diag::warn_atomic_implicit_seq_cst);"},{u,14673,"static void CheckImplicitConversion(Sema &S, Expr *E, QualType T, SourceLocation CC, bool *ICContext = nullptr, bool IsListInit = false) {\n // ...\n if (Source->isAtomicType())\n S.Diag(E->getExprLoc(), diag::warn_atomic_implicit_seq_cst);"},{u,15288,"/// Data recursive variant of AnalyzeImplicitConversions. Subexpressions\n/// that should be visited are added to WorkList.\nstatic void AnalyzeImplicitConversions(Sema &S, AnalyzeImplicitConversionsWorkItem Item, llvm::SmallVectorImpl<AnalyzeImplicitConversionsWorkItem> &WorkList) {\n // ...\n // Skip past explicit casts.\n if (auto *CE = dyn_cast<ExplicitCastExpr>(E)) {\n // ...\n if (!CE->getType()->isVoidType() && E->getType()->isAtomicType())\n S.Diag(E->getBeginLoc(), diag::warn_atomic_implicit_seq_cst);"},{u,15355,"/// Data recursive variant of AnalyzeImplicitConversions. Subexpressions\n/// that should be visited are added to WorkList.\nstatic void AnalyzeImplicitConversions(Sema &S, AnalyzeImplicitConversionsWorkItem Item, llvm::SmallVectorImpl<AnalyzeImplicitConversionsWorkItem> &WorkList) {\n // ...\n if (const UnaryOperator *U = dyn_cast<UnaryOperator>(E)) {\n if (U->getOpcode() == UO_LNot) {\n // ...\n } else if (U->getOpcode() != UO_AddrOf) {\n if (U->getSubExpr()->getType()->isAtomicType())\n S.Diag(U->getSubExpr()->getBeginLoc(), diag::warn_atomic_implicit_seq_cst);"}},
[l]={
["clang/test/Sema/atomic-implicit-seq_cst.c"]={
[1]="clang/test/Sema/atomic-implicit-seq_cst.c:10:5: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[2]="clang/test/Sema/atomic-implicit-seq_cst.c:14:5: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[3]="clang/test/Sema/atomic-implicit-seq_cst.c:18:3: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[4]="clang/test/Sema/atomic-implicit-seq_cst.c:22:3: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[5]="clang/test/Sema/atomic-implicit-seq_cst.c:26:13: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[6]="clang/test/Sema/atomic-implicit-seq_cst.c:30:11: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[7]="clang/test/Sema/atomic-implicit-seq_cst.c:34:11: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[8]="clang/test/Sema/atomic-implicit-seq_cst.c:38:11: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[9]="clang/test/Sema/atomic-implicit-seq_cst.c:42:11: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[10]="clang/test/Sema/atomic-implicit-seq_cst.c:46:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[11]="clang/test/Sema/atomic-implicit-seq_cst.c:50:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[12]="clang/test/Sema/atomic-implicit-seq_cst.c:54:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[13]="clang/test/Sema/atomic-implicit-seq_cst.c:58:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[14]="clang/test/Sema/atomic-implicit-seq_cst.c:62:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[15]="clang/test/Sema/atomic-implicit-seq_cst.c:66:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[16]="clang/test/Sema/atomic-implicit-seq_cst.c:70:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[17]="clang/test/Sema/atomic-implicit-seq_cst.c:74:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[18]="clang/test/Sema/atomic-implicit-seq_cst.c:78:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[19]="clang/test/Sema/atomic-implicit-seq_cst.c:82:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[20]="clang/test/Sema/atomic-implicit-seq_cst.c:86:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[21]="clang/test/Sema/atomic-implicit-seq_cst.c:90:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[22]="clang/test/Sema/atomic-implicit-seq_cst.c:94:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[23]="clang/test/Sema/atomic-implicit-seq_cst.c:98:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[24]="clang/test/Sema/atomic-implicit-seq_cst.c:102:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[25]="clang/test/Sema/atomic-implicit-seq_cst.c:106:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[26]="clang/test/Sema/atomic-implicit-seq_cst.c:110:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[27]="clang/test/Sema/atomic-implicit-seq_cst.c:114:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[28]="clang/test/Sema/atomic-implicit-seq_cst.c:118:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[29]="clang/test/Sema/atomic-implicit-seq_cst.c:122:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[30]="clang/test/Sema/atomic-implicit-seq_cst.c:126:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[31]="clang/test/Sema/atomic-implicit-seq_cst.c:130:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[32]="clang/test/Sema/atomic-implicit-seq_cst.c:134:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[33]="clang/test/Sema/atomic-implicit-seq_cst.c:138:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[34]="clang/test/Sema/atomic-implicit-seq_cst.c:142:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[35]="clang/test/Sema/atomic-implicit-seq_cst.c:146:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[36]="clang/test/Sema/atomic-implicit-seq_cst.c:150:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[37]="clang/test/Sema/atomic-implicit-seq_cst.c:154:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[38]="clang/test/Sema/atomic-implicit-seq_cst.c:158:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[39]="clang/test/Sema/atomic-implicit-seq_cst.c:162:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[40]="clang/test/Sema/atomic-implicit-seq_cst.c:166:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[41]="clang/test/Sema/atomic-implicit-seq_cst.c:170:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[42]="clang/test/Sema/atomic-implicit-seq_cst.c:174:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[43]="clang/test/Sema/atomic-implicit-seq_cst.c:178:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[44]="clang/test/Sema/atomic-implicit-seq_cst.c:182:12: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[45]="clang/test/Sema/atomic-implicit-seq_cst.c:186:16: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[46]="clang/test/Sema/atomic-implicit-seq_cst.c:190:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[47]="clang/test/Sema/atomic-implicit-seq_cst.c:194:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[48]="clang/test/Sema/atomic-implicit-seq_cst.c:198:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[49]="clang/test/Sema/atomic-implicit-seq_cst.c:202:15: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[50]="clang/test/Sema/atomic-implicit-seq_cst.c:205:14: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[51]="clang/test/Sema/atomic-implicit-seq_cst.c:209:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[52]="clang/test/Sema/atomic-implicit-seq_cst.c:213:18: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[53]="clang/test/Sema/atomic-implicit-seq_cst.c:217:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[54]="clang/test/Sema/atomic-implicit-seq_cst.c:221:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[55]="clang/test/Sema/atomic-implicit-seq_cst.c:225:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[56]="clang/test/Sema/atomic-implicit-seq_cst.c:229:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[57]="clang/test/Sema/atomic-implicit-seq_cst.c:233:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[58]="clang/test/Sema/atomic-implicit-seq_cst.c:237:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[59]="clang/test/Sema/atomic-implicit-seq_cst.c:241:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[60]="clang/test/Sema/atomic-implicit-seq_cst.c:245:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[61]="clang/test/Sema/atomic-implicit-seq_cst.c:249:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[62]="clang/test/Sema/atomic-implicit-seq_cst.c:253:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[63]="clang/test/Sema/atomic-implicit-seq_cst.c:257:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[64]="clang/test/Sema/atomic-implicit-seq_cst.c:261:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[65]="clang/test/Sema/atomic-implicit-seq_cst.c:265:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[66]="clang/test/Sema/atomic-implicit-seq_cst.c:269:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[67]="clang/test/Sema/atomic-implicit-seq_cst.c:273:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[68]="clang/test/Sema/atomic-implicit-seq_cst.c:277:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[69]="clang/test/Sema/atomic-implicit-seq_cst.c:281:10: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[70]="clang/test/Sema/atomic-implicit-seq_cst.c:285:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[71]="clang/test/Sema/atomic-implicit-seq_cst.c:289:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[72]="clang/test/Sema/atomic-implicit-seq_cst.c:293:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[73]="clang/test/Sema/atomic-implicit-seq_cst.c:297:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[74]="clang/test/Sema/atomic-implicit-seq_cst.c:301:8: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[75]="clang/test/Sema/atomic-implicit-seq_cst.c:305:9: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]",
[76]="clang/test/Sema/atomic-implicit-seq_cst.c:309:19: warning: implicit use of sequentially-consistent atomic may incur stronger memory barriers than necessary [-Watomic-implicit-seq-cst]"
}
}
},
["warn_atomic_member_access"]={
[j]={"atomic-access"},
[k]="atomic-access",
[g]={{nil,D,"warn_atomic_member_access"}},
[b]={{nil,D,"accessing a member of an atomic structure or union is undefined behavior"}},
[c]={{nil,D,"accessing a member of an atomic structure or union is undefined behavior"}},
[d]=zc,
[e]="accessing a member of an atomic structure or union is undefined behavior",
[f]=" \\[[^\\]]*\\-Watomic\\-access[^\\]]*\\]",
[h]={{nil,D,n}},
[a]={"f60dc3caa673",1620118562,"[C++20][Modules] Adjust handling of exports of namespaces and using-decls.","[C++20][Modules] Adjust handling of exports of namespaces and using-decls.\n\nThis adjusts the handling for:\n\nexport module M;\n\nexport namespace {};\n\nexport namespace N {};\nexport using namespace N;\n\nIn the first case, we were allowing empty anonymous namespaces\nas part of an extension allowing empty top-level entities, but that seems\ninappropriate in this case, since the linkage would be internal for the\nanonymous namespace. We now report an error for this.\n\nThe second case was producing a warning diagnostic that this was\naccepted as an extension - however the C++20 standard does allow this\nas well-formed.\n\nIn the third case we keep the current practice that this is accepted with a\nwarning (as an extension). The C++20 standard says it\'s an error.\n\nWe also ensure that using decls are only applied to items with external linkage.\n\nThis adjusts error messages for exports involving redeclarations in modules to\nbe more specific about the reason that the decl has been rejected.\n\nDifferential Revision: https://reviews.llvm.org/D122119"},
[i]={{"clang/lib/Sema/SemaExprMember.cpp",1306,"/// Look up the given member of the given non-type-dependent\n/// expression. This can return in one of two ways:\n/// * If it returns a sentinel null-but-valid result, the caller will\n/// assume that lookup was performed and the results written into\n/// the provided structure. It will take over from there.\n/// * Otherwise, the returned expression will be produced in place of\n/// an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n // ...\n // If the base type is an atomic type, this access is undefined behavior per\n // C11 6.5.2.3p5. Instead of giving a typecheck error, we\'ll warn the user\n // about the UB and recover by converting the atomic lvalue into a non-atomic\n // lvalue. Because this is inherently unsafe as an atomic operation, the\n // warning defaults to an error.\n if (const auto *ATy = BaseType->getAs<AtomicType>()) {\n S.DiagRuntimeBehavior(OpLoc, nullptr, S.PDiag(diag::warn_atomic_member_access));"}},
[l]={
["clang/test/Sema/atomic-expr.c"]={"clang/test/Sema/atomic-expr.c:86:4: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:87:5: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:93:4: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:94:5: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:97:15: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:98:12: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:99:15: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:100:12: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:104:4: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]","clang/test/Sema/atomic-expr.c:105:15: error: accessing a member of an atomic structure or union is undefined behavior [-Watomic-access]"}
}
},
["warn_atomic_op_has_invalid_memory_order"]={
[j]={"atomic-memory-ordering"},
[k]="atomic-memory-ordering",
[g]="warn_atomic_op_has_invalid_memory_order",
[b]="memory order argument to atomic operation is invalid",
[c]="memory order argument to atomic operation is invalid",
[d]=m,
[e]="memory order argument to atomic operation is invalid",
[f]=" \\[(?:\\-Werror,)?\\-Watomic\\-memory\\-ordering[^\\]]*\\]",
[h]=n,
[a]={"c83472e0ff4c",1394537710,"Sema: demote invalid atomic ordering message to warning.","Sema: demote invalid atomic ordering message to warning.\n\nSomeone could write:\n if (0) {\n __c11_atomic_load(ptr, memory_order_release);\n }\n\nor the equivalent, which is perfectly valid, so we shouldn\'t outright reject\ninvalid orderings on purely static grounds.\n\nrdar://problem/16242991\n\nllvm-svn: 203564"},
[i]={{u,4449,"bool Sema::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n // ...\n // Check validity of memory ordering as per C11 / C++11\'s memody model.\n // Only fence needs check. Atomic dec/inc allow all memory orders.\n if (!llvm::isValidAtomicOrderingCABI(Ord))\n return Diag(ArgExpr->getBeginLoc(), diag::warn_atomic_op_has_invalid_memory_order) << ArgExpr->getSourceRange();"},{u,4456,"bool Sema::CheckAMDGCNBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n // ...\n case llvm::AtomicOrderingCABI::relaxed:\n case llvm::AtomicOrderingCABI::consume:\n if (BuiltinID == AMDGPU::BI__builtin_amdgcn_fence)\n return Diag(ArgExpr->getBeginLoc(), diag::warn_atomic_op_has_invalid_memory_order) << ArgExpr->getSourceRange();"},{u,7427,"ExprResult Sema::BuildAtomicExpr(SourceRange CallRange, SourceRange ExprRange, SourceLocation RParenLoc, MultiExprArg Args, AtomicExpr::AtomicOp Op, AtomicArgumentOrder ArgOrder) {\n // ...\n if (SubExprs.size() >= 2 && Form != Init) {\n if (std::optional<llvm::APSInt> Result = SubExprs[1]->getIntegerConstantExpr(Context))\n if (!isValidOrderingForOp(Result->getSExtValue(), Op))\n Diag(SubExprs[1]->getBeginLoc(), diag::warn_atomic_op_has_invalid_memory_order) << SubExprs[1]->getSourceRange();"}},
[l]={
["clang/test/SemaCUDA/atomic-ops.cu"]={"clang/test/SemaCUDA/atomic-ops.cu:20:33: warning: memory order argument to atomic operation is invalid [-Watomic-memory-ordering]","clang/test/SemaCUDA/atomic-ops.cu:43:31: warning: memory order argument to atomic operation is invalid [-Watomic-memory-ordering]","clang/test/SemaCUDA/atomic-ops.cu:44:31: warning: memory order argument to atomic operation is invalid [-Watomic-memory-ordering]","clang/test/SemaCUDA/atomic-ops.cu:45:31: warning: memory order argument to atomic operation is invalid [-Watomic-memory-ordering]"}
}
},
["warn_atomic_op_misaligned"]={
[j]={"atomic-alignment"},
[k]="atomic-alignment",
[g]={{nil,F,"warn_atomic_op_misaligned"}},
[b]={{nil,p,"misaligned atomic operation may incur significant performance penalty; the expected alignment (%0 bytes) exceeds the actual alignment (%1 bytes)"},{"11.1",V,"%select{large|misaligned}0 atomic operation may incur significant performance penalty"},{Sc,F,"misaligned or large atomic operation may incur significant performance penalty"}},
[c]={{nil,p,"misaligned atomic operation may incur significant performance penalty; the expected alignment (A bytes) exceeds the actual alignment (B bytes)"},{"11.1",V,{{"large","misaligned"}," atomic operation may incur significant performance penalty"}},{Sc,F,"misaligned or large atomic operation may incur significant performance penalty"}},
[d]=m,
[e]="misaligned atomic operation may incur significant performance penalty; the expected alignment \\((.*?) bytes\\) exceeds the actual alignment \\((.*?) bytes\\)",
[f]=" \\[(?:\\-Werror,)?\\-Watomic\\-alignment[^\\]]*\\]",
[h]={{nil,V,O},{Sc,F,n}},
[a]={"9dc1d0c74eb1",1524471384,"[Atomics] warn about atomic accesses using libcalls","[Atomics] warn about atomic accesses using libcalls\n\nIf an atomic variable is misaligned (and that suspicion is why Clang emits\nlibcalls at all) the runtime support library will have to use a lock to safely\naccess it, with potentially very bad performance consequences. There\'s a very\ngood chance this is unintentional so it makes sense to issue a warning.\n\nAlso give it a named group so people can promote it to an error, or disable it\nif they really don\'t care.\n\nllvm-svn: 330566"},
[i]={{"clang/lib/CodeGen/CGAtomic.cpp",847,"RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {\n // ...\n if (Misaligned) {\n Diags.Report(E->getBeginLoc(), diag::warn_atomic_op_misaligned) << (int)TInfo.Width.getQuantity() << (int)Ptr.getAlignment().getQuantity();"}},
[l]={
["clang/test/CodeGen/atomic-arm64.c"]={"clang/test/CodeGen/atomic-arm64.c:69:3: warning: misaligned atomic operation may incur significant performance penalty; the expected alignment (32 bytes) exceeds the actual alignment (8 bytes) [-Watomic-alignment]"}
}
},
["warn_atomic_op_oversized"]={
[j]={"atomic-alignment"},
[k]="atomic-alignment",
[g]={{nil,p,"warn_atomic_op_oversized"}},
[b]={{nil,p,"large atomic operation may incur significant performance penalty; the access size (%0 bytes) exceeds the max lock-free size (%1 bytes)"}},
[c]={{nil,p,"large atomic operation may incur significant performance penalty; the access size (A bytes) exceeds the max lock-free size (B bytes)"}},
[d]=m,
[e]="large atomic operation may incur significant performance penalty; the access size \\((.*?) bytes\\) exceeds the max lock\\-free size \\((.*?) bytes\\)",
[f]=" \\[(?:\\-Werror,)?\\-Watomic\\-alignment[^\\]]*\\]",
[h]={{nil,p,O}},
[a]={"e18c6ef6b41a",1596564601,"[clang] improve diagnostics for misaligned and large atomics","[clang] improve diagnostics for misaligned and large atomics\n\n\"Listing the alignment and access size (== expected alignment) in the warning\nseems like a good idea.\"\n\nsolves PR 46947\n\n struct Foo {\n struct Bar {\n void * a;\n void * b;\n };\n Bar bar;\n };\n\n struct ThirtyTwo {\n struct Large {\n void * a;\n void * b;\n void * c;\n void * d;\n };\n Large bar;\n };\n\n void braz(Foo *foo, ThirtyTwo *braz) {\n Foo::Bar bar;\n __atomic_load(&foo->bar, &bar, __ATOMIC_RELAXED);\n\n ThirtyTwo::Large foobar;\n __atomic_load(&braz->bar, &foobar, __ATOMIC_RELAXED);\n }\n\nrepro.cpp:21:3: warning: misaligned atomic operation may incur significant performance penalty; the expected (16 bytes) exceeds the actual alignment (8 bytes) [-Watomic-alignment]\n __atomic_load(&foo->bar, &bar, __ATOMIC_RELAXED);\n ^\nrepro.cpp:24:3: warning: misaligned atomic operation may incur significant performance penalty; the expected (32 bytes) exceeds the actual alignment (8 bytes) [-Watomic-alignment]\n __atomic_load(&braz->bar, &foobar, __ATOMIC_RELAXED);\n ^\nrepro.cpp:24:3: warning: large atomic operation may incur significant performance penalty; the access size (32 bytes) exceeds the max lock-free size (16 bytes) [-Watomic-alignment]\n3 warnings generated.\n\nDifferential Revision: https://reviews.llvm.org/D85102"},
[i]={{"clang/lib/CodeGen/CGAtomic.cpp",853,"RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E) {\n // ...\n if (Oversized) {\n Diags.Report(E->getBeginLoc(), diag::warn_atomic_op_oversized) << (int)TInfo.Width.getQuantity() << (int)MaxInlineWidth.getQuantity();"}},
[l]={
["clang/test/CodeGen/arm-atomics-m0.c"]={"clang/test/CodeGen/arm-atomics-m0.c:15:3: warning: large atomic operation may incur significant performance penalty; the access size (4 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:17:3: warning: large atomic operation may incur significant performance penalty; the access size (4 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:20:3: warning: large atomic operation may incur significant performance penalty; the access size (4 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:23:3: warning: large atomic operation may incur significant performance penalty; the access size (4 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:26:3: warning: large atomic operation may incur significant performance penalty; the access size (8 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:28:3: warning: large atomic operation may incur significant performance penalty; the access size (8 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:31:3: warning: large atomic operation may incur significant performance penalty; the access size (8 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]","clang/test/CodeGen/arm-atomics-m0.c:34:3: warning: large atomic operation may incur significant performance penalty; the access size (8 bytes) exceeds the max lock-free size (0 bytes) [-Watomic-alignment]"}
}
},
["warn_atomic_property_rule"]={
[j]={"atomic-property-with-user-defined-accessor"},
[k]="atomic-property-with-user-defined-accessor",
[g]="warn_atomic_property_rule",
[b]="writable atomic property %0 cannot pair a synthesized %select{getter|setter}1 with a user defined %select{getter|setter}2",
[c]={{nil,nil,{"writable atomic property A cannot pair a synthesized ",{"getter","setter"}," with a user defined ",{"getter","setter"}}}},
[d]=m,
[e]="writable atomic property (.*?) cannot pair a synthesized (?:getter|setter) with a user defined (?:getter|setter)",
[f]=" \\[(?:\\-Werror,)?\\-Watomic\\-property\\-with\\-user\\-defined\\-accessor[^\\]]*\\]",
[h]=n,
[a]={"13e0c90fc1a9",1257979211,"writable atomic property\'s setter/getter must be in \'lock\' step of","writable atomic property\'s setter/getter must be in \'lock\' step of\neither both synthesized or bith user defined. \nImplements radar 6557233.\n\nllvm-svn: 86887"},
[i]={{pb,2228,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n // ...\n for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n // ...\n if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(Property->getIdentifier(), Property->getQueryKind())) {\n // ...\n if ((bool)GetterMethod ^ (bool)SetterMethod) {\n // ...\n Diag(MethodLoc, diag::warn_atomic_property_rule) << Property->getIdentifier() << (GetterMethod != nullptr) << (SetterMethod != nullptr);"}},
[l]={
["clang/test/SemaObjC/atomic-property-synthesis-rules.m"]={"clang/test/SemaObjC/atomic-property-synthesis-rules.m:251:1: warning: writable atomic property \'Get\' cannot pair a synthesized setter with a user defined getter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:252:1: warning: writable atomic property \'Set\' cannot pair a synthesized getter with a user defined setter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:269:1: warning: writable atomic property \'Get_ReadWriteInExt\' cannot pair a synthesized setter with a user defined getter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:270:1: warning: writable atomic property \'Set_ReadWriteInExt\' cannot pair a synthesized getter with a user defined setter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:279:1: warning: writable atomic property \'Get_LateSynthesize\' cannot pair a synthesized setter with a user defined getter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:280:1: warning: writable atomic property \'Set_LateSynthesize\' cannot pair a synthesized getter with a user defined setter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:297:1: warning: writable atomic property \'Get_ReadWriteInExt_LateSynthesize\' cannot pair a synthesized setter with a user defined getter [-Watomic-property-with-user-defined-accessor]","clang/test/SemaObjC/atomic-property-synthesis-rules.m:298:1: warning: writable atomic property \'Set_ReadWriteInExt_LateSynthesize\' cannot pair a synthesized getter with a user defined setter [-Watomic-property-with-user-defined-accessor]"}
}
},
["warn_attr_abi_tag_namespace"]={
[j]={x,q},
[k]=q,
[g]="warn_attr_abi_tag_namespace",
[b]="\'abi_tag\' attribute on %select{non-inline|anonymous}0 namespace ignored",
[c]={{nil,nil,{"\'abi_tag\' attribute on ",{"non-inline","anonymous"}," namespace ignored"}}},
[d]=m,
[e]="\'abi_tag\' attribute on (?:non\\-inline|anonymous) namespace ignored",
[f]=y,
[h]=n,
[a]={"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"},
[i]={{o,7331,"static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {\n if (!NS->isInline()) {\n S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 0;"},{o,7335,"static void handleAbiTagAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *NS = dyn_cast<NamespaceDecl>(D)) {\n // ...\n if (NS->isAnonymousNamespace()) {\n S.Diag(AL.getLoc(), diag::warn_attr_abi_tag_namespace) << 1;"}},
[l]={
["clang/test/SemaCXX/attr-abi-tag-syntax.cpp"]={"clang/test/SemaCXX/attr-abi-tag-syntax.cpp:5:26: warning: \'abi_tag\' attribute on non-inline namespace ignored [-Wignored-attributes]","clang/test/SemaCXX/attr-abi-tag-syntax.cpp:8:28: warning: \'abi_tag\' attribute on non-inline namespace ignored [-Wignored-attributes]","clang/test/SemaCXX/attr-abi-tag-syntax.cpp:15:33: warning: \'abi_tag\' attribute on anonymous namespace ignored [-Wignored-attributes]"}
}
},
["warn_attr_on_unconsumable_class"]={
[j]={"consumed"},
[k]="consumed",
[g]="warn_attr_on_unconsumable_class",
[b]={{nil,t,"consumed analysis attribute is attached to member of class %0 which isn\'t marked as consumable"},{s,nil,"consumed analysis attribute is attached to member of class \'%0\' which isn\'t marked as consumable"}},
[c]={{nil,t,"consumed analysis attribute is attached to member of class A which isn\'t marked as consumable"},{s,nil,"consumed analysis attribute is attached to member of class \'A\' which isn\'t marked as consumable"}},
[d]=m,
[e]="consumed analysis attribute is attached to member of class (.*?) which isn\'t marked as consumable",
[f]=" \\[(?:\\-Werror,)?\\-Wconsumed[^\\]]*\\]",
[h]=n,
[a]={"5a715c4f00ac",1377903394,"Consumed analysis: add \'consumable\' class attribute.","Consumed analysis: add \'consumable\' class attribute.\nPatch by chris.wailes@gmail.com\n\nAdds the \'consumable\' attribute that can be attached to classes. This replaces\nthe previous method of scanning a class\'s methods to see if any of them have\nconsumed analysis attributes attached to them. If consumed analysis attributes\nare attached to methods of a class that isn\'t marked \'consumable\' a warning\nis generated.\n\nllvm-svn: 189702"},
[i]={{o,1231,"static bool checkForConsumableClass(Sema &S, const CXXMethodDecl *MD, const ParsedAttr &AL) {\n // ...\n if (const CXXRecordDecl *RD = ThisType->getAsCXXRecordDecl()) {\n if (!RD->hasAttr<ConsumableAttr>()) {\n S.Diag(AL.getLoc(), diag::warn_attr_on_unconsumable_class) << RD;"}},
[l]={
["clang/test/SemaCXX/warn-consumed-parsing.cpp"]={"clang/test/SemaCXX/warn-consumed-parsing.cpp:51:25: warning: consumed analysis attribute is attached to member of class \'AttrTester2\' which isn\'t marked as consumable [-Wconsumed]","clang/test/SemaCXX/warn-consumed-parsing.cpp:52:25: warning: consumed analysis attribute is attached to member of class \'AttrTester2\' which isn\'t marked as consumable [-Wconsumed]","clang/test/SemaCXX/warn-consumed-parsing.cpp:53:25: warning: consumed analysis attribute is attached to member of class \'AttrTester2\' which isn\'t marked as consumable [-Wconsumed]"}
}
},
["warn_attr_swift_name_decl_kind"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_decl_kind"}},
[b]={{nil,p,"%0 attribute cannot be applied to this declaration"}},
[c]={{nil,p,"A attribute cannot be applied to this declaration"}},
[d]=m,
[e]="(.*?) attribute cannot be applied to this declaration",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6856,"bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, const ParsedAttr &AL, bool IsAsync) {\n if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {\n // ...\n } else if ((isa<EnumConstantDecl>(D) || isa<ObjCProtocolDecl>(D) || isa<ObjCInterfaceDecl>(D) || isa<ObjCPropertyDecl>(D) || isa<VarDecl>(D) || isa<TypedefNameDecl>(D) || isa<TagDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FieldDecl>(D)) && !IsAsync) {\n // ...\n } else {\n Diag(Loc, diag::warn_attr_swift_name_decl_kind) << AL;"}}
},
["warn_attr_swift_name_decl_missing_params"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_decl_missing_params"}},
[b]={{nil,p,"%0 attribute cannot be applied to a %select{function|method}1 with no parameters"}},
[c]={{nil,p,{"A attribute cannot be applied to a ",{sc,"method"}," with no parameters"}}},
[d]=m,
[e]="(.*?) attribute cannot be applied to a (?:function|method) with no parameters",
[f]=fb,
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{o,6794,"bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, const ParsedAttr &AL, bool IsAsync) {\n if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {\n // ...\n // The async name drops the last callback parameter.\n if (IsAsync) {\n if (ParamCount == 0) {\n Diag(Loc, diag::warn_attr_swift_name_decl_missing_params) << AL << isa<ObjCMethodDecl>(D);"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:191:42: warning: \'__swift_async_name__\' attribute cannot be applied to a method with no parameters [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:201:43: warning: \'__swift_async_name__\' attribute cannot be applied to a function with no parameters [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_function"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_function"}},
[b]={{nil,p,"%0 attribute argument must be a string literal specifying a Swift function name"}},
[c]={{nil,p,"A attribute argument must be a string literal specifying a Swift function name"}},
[d]=m,
[e]="(.*?) attribute argument must be a string literal specifying a Swift function name",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6602,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (Name.back() != \')\') {\n S.Diag(Loc, diag::warn_attr_swift_name_function) << AL;"},{o,6664,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (Parameters.back() != \':\') {\n S.Diag(Loc, diag::warn_attr_swift_name_function) << AL;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:27:45: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:57:42: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:59:42: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:82:27: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:161:34: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:164:46: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:167:43: warning: \'__swift_name__\' attribute argument must be a string literal specifying a Swift function name [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_getter_parameters"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_getter_parameters"}},
[b]={{nil,p,"%0 attribute for getter must not have any parameters besides \'self:\'"}},
[c]={{nil,p,"A attribute for getter must not have any parameters besides \'self:\'"}},
[d]=m,
[e]="(.*?) attribute for getter must not have any parameters besides \'self\\:\'",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6720,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // Check the number of parameters for a getter/setter.\n if (IsGetter || IsSetter) {\n // ...\n unsigned ParamDiag = IsGetter ? diag::warn_attr_swift_name_getter_parameters : diag::warn_attr_swift_name_setter_parameters;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:104:78: warning: \'__swift_name__\' attribute for getter must not have any parameters besides \'self:\' [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:158:38: warning: \'__swift_name__\' attribute for getter must not have any parameters besides \'self:\' [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_invalid_identifier"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_invalid_identifier"}},
[b]={{nil,p,"%0 attribute has invalid identifier for the %select{base|context|parameter}1 name"}},
[c]={{nil,p,{"A attribute has invalid identifier for the ",{"base","context","parameter"}," name"}}},
[d]=m,
[e]="(.*?) attribute has invalid identifier for the (?:base|context|parameter) name",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6618,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (BaseName.empty()) {\n // ...\n } else if (ContextName.empty() || !isValidAsciiIdentifier(ContextName)) {\n S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL << /*context*/ 1;"},{o,6626,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (!isValidAsciiIdentifier(BaseName) || BaseName == \"_\") {\n S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL << /*basename*/ 0;"},{o,6676,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n do {\n // ...\n if (!isValidAsciiIdentifier(CurrentParam)) {\n S.Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL << /*parameter*/ 2;"},{o,6845,"bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, const ParsedAttr &AL, bool IsAsync) {\n if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {\n // ...\n } else if ((isa<EnumConstantDecl>(D) || isa<ObjCProtocolDecl>(D) || isa<ObjCInterfaceDecl>(D) || isa<ObjCPropertyDecl>(D) || isa<VarDecl>(D) || isa<TypedefNameDecl>(D) || isa<TagDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FieldDecl>(D)) && !IsAsync) {\n // ...\n if (BaseName.empty()) {\n // ...\n } else if (!isValidAsciiIdentifier(ContextName)) {\n Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL << /*context*/ 1;"},{o,6851,"bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, const ParsedAttr &AL, bool IsAsync) {\n if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {\n // ...\n } else if ((isa<EnumConstantDecl>(D) || isa<ObjCProtocolDecl>(D) || isa<ObjCInterfaceDecl>(D) || isa<ObjCPropertyDecl>(D) || isa<VarDecl>(D) || isa<TypedefNameDecl>(D) || isa<TagDecl>(D) || isa<IndirectFieldDecl>(D) || isa<FieldDecl>(D)) && !IsAsync) {\n // ...\n if (!isValidAsciiIdentifier(BaseName)) {\n Diag(Loc, diag::warn_attr_swift_name_invalid_identifier) << AL << /*basename*/ 0;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:61:53: warning: \'__swift_name__\' attribute has invalid identifier for the base name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:63:53: warning: \'__swift_name__\' attribute has invalid identifier for the parameter name [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:73:21: warning: \'__swift_name__\' attribute has invalid identifier for the base name [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_missing_parameters"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_missing_parameters"}},
[b]={{nil,p,"%0 attribute is missing parameter label clause"}},
[c]={{nil,p,"A attribute is missing parameter label clause"}},
[d]=m,
[e]="(.*?) attribute is missing parameter label clause",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6640,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (Parameters.empty()) {\n S.Diag(Loc, diag::warn_attr_swift_name_missing_parameters) << AL;"}}
},
["warn_attr_swift_name_multiple_selfs"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_multiple_selfs"}},
[b]={{nil,p,"%0 attribute cannot specify more than one \'self:\' parameter"}},
[c]={{nil,p,"A attribute cannot specify more than one \'self:\' parameter"}},
[d]=m,
[e]="(.*?) attribute cannot specify more than one \'self\\:\' parameter",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6686,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n do {\n // ...\n if (IsMember && CurrentParam == \"self\") {\n // ...\n // More than one \"self\"?\n if (SelfLocation) {\n S.Diag(Loc, diag::warn_attr_swift_name_multiple_selfs) << AL;"}}
},
["warn_attr_swift_name_num_params"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_num_params"}},
[b]={{nil,p,"too %select{few|many}0 parameters in the signature specified by the %1 attribute (expected %2; got %3)"}},
[c]={{nil,p,{"too ",{"few","many"}," parameters in the signature specified by the B attribute (expected C; got D)"}}},
[d]=m,
[e]="too (?:few|many) parameters in the signature specified by the (.*?) attribute \\(expected (.*?); got (.*?)\\)",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6828,"bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, const ParsedAttr &AL, bool IsAsync) {\n if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {\n // ...\n if (!ParamCountValid) {\n Diag(Loc, diag::warn_attr_swift_name_num_params) << (SwiftParamCount > ParamCount) << AL << ParamCount << SwiftParamCount;"}},
[l]={
["clang/test/SemaObjCXX/attr-swift_name-cxx.mm"]={"clang/test/SemaObjCXX/attr-swift_name-cxx.mm:12:85: warning: too few parameters in the signature specified by the \'__swift_async_name__\' attribute (expected 1; got 0) [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_setter_parameters"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_setter_parameters"}},
[b]={{nil,p,"%0 attribute for setter must have one parameter for new value"}},
[c]={{nil,p,"A attribute for setter must have one parameter for new value"}},
[d]=m,
[e]="(.*?) attribute for setter must have one parameter for new value",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6656,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (Parameters.empty()) {\n // ...\n if (IsSetter) {\n S.Diag(Loc, diag::warn_attr_swift_name_setter_parameters) << AL;"},{o,6721,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // Check the number of parameters for a getter/setter.\n if (IsGetter || IsSetter) {\n // ...\n unsigned ParamDiag = IsGetter ? diag::warn_attr_swift_name_getter_parameters : diag::warn_attr_swift_name_setter_parameters;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:113:88: warning: \'__swift_name__\' attribute for setter must have one parameter for new value [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_subscript_getter_newValue"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_subscript_getter_newValue"}},
[b]={{nil,p,"%0 attribute for \'subscript\' getter cannot have a \'newValue:\' parameter"}},
[c]={{nil,p,"A attribute for \'subscript\' getter cannot have a \'newValue:\' parameter"}},
[d]=m,
[e]="(.*?) attribute for \'subscript\' getter cannot have a \'newValue\\:\' parameter",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6751,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // Check the number of parameters for a getter/setter.\n if (IsGetter || IsSetter) {\n // ...\n // Subscripts may have additional parameters beyond the expected params for\n // the index.\n if (IsSubscript) {\n // ...\n // A subscript setter must explicitly label its newValue parameter to\n // distinguish it from index parameters.\n if (IsSetter) {\n // ...\n } else {\n // Subscript getters should have no \'newValue:\' parameter.\n if (NewValueLocation) {\n S.Diag(Loc, diag::warn_attr_swift_name_subscript_getter_newValue) << AL;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:131:94: warning: \'__swift_name__\' attribute for \'subscript\' getter cannot have a \'newValue:\' parameter [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_subscript_invalid_parameter"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_subscript_invalid_parameter"}},
[b]={{nil,p,"%0 attribute for \'subscript\' must %select{be a getter or setter|have at least one parameter|have a \'self:\' parameter}1"}},
[c]={{nil,p,{"A attribute for \'subscript\' must ",{"be a getter or setter","have at least one parameter","have a \'self:\' parameter"}}}},
[d]=m,
[e]="(.*?) attribute for \'subscript\' must (?:be a getter or setter|have at least one parameter|have a \'self\\:\' parameter)",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6634,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // A subscript accessor must be a getter or setter.\n if (IsSubscript && !IsGetter && !IsSetter) {\n S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter) << AL << /* getter or setter */ 0;"},{o,6650,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n if (Parameters.empty()) {\n // Setters and subscripts must have at least one parameter.\n if (IsSubscript) {\n S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter) << AL << /* have at least one parameter */ 1;"},{o,6707,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // Only instance subscripts are currently supported.\n if (IsSubscript && !SelfLocation) {\n S.Diag(Loc, diag::warn_attr_swift_name_subscript_invalid_parameter) << AL << /*have a \'self:\' parameter*/ 2;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:125:80: warning: \'__swift_name__\' attribute for \'subscript\' must be a getter or setter [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:137:53: warning: \'__swift_name__\' attribute for \'subscript\' must have a \'self:\' parameter [-Wswift-name-attribute]","clang/test/SemaObjC/attr-swift_name.m:140:53: warning: \'__swift_name__\' attribute for \'subscript\' must have at least one parameter [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_subscript_setter_multiple_newValues"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_subscript_setter_multiple_newValues"}},
[b]={{nil,p,"%0 attribute for \'subscript\' setter cannot have multiple \'newValue:\' parameters"}},
[c]={{nil,p,"A attribute for \'subscript\' setter cannot have multiple \'newValue:\' parameters"}},
[d]=m,
[e]="(.*?) attribute for \'subscript\' setter cannot have multiple \'newValue\\:\' parameters",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6744,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // Check the number of parameters for a getter/setter.\n if (IsGetter || IsSetter) {\n // ...\n // Subscripts may have additional parameters beyond the expected params for\n // the index.\n if (IsSubscript) {\n // ...\n // A subscript setter must explicitly label its newValue parameter to\n // distinguish it from index parameters.\n if (IsSetter) {\n // ...\n if (NewValueCount > 1) {\n S.Diag(Loc, diag::warn_attr_swift_name_subscript_setter_multiple_newValues) << AL;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:128:97: warning: \'__swift_name__\' attribute for \'subscript\' setter cannot have multiple \'newValue:\' parameters [-Wswift-name-attribute]"}
}
},
["warn_attr_swift_name_subscript_setter_no_newValue"]={
[j]={L},
[k]=L,
[g]={{nil,p,"warn_attr_swift_name_subscript_setter_no_newValue"}},
[b]={{nil,p,"%0 attribute for \'subscript\' setter must have a \'newValue:\' parameter"}},
[c]={{nil,p,"A attribute for \'subscript\' setter must have a \'newValue:\' parameter"}},
[d]=m,
[e]="(.*?) attribute for \'subscript\' setter must have a \'newValue\\:\' parameter",
[f]=fb,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{o,6739,"// For a function, this will validate a compound Swift name, e.g.\n// <code>init(foo:bar:baz:)</code> or <code>controllerForName(_:)</code>, and\n// the function will output the number of parameter names, and whether this is a\n// single-arg initializer.\n//\n// For a type, enum constant, property, or variable declaration, this will\n// validate either a simple identifier, or a qualified\n// <code>context.identifier</code> name.\nstatic bool validateSwiftFunctionName(Sema &S, const ParsedAttr &AL, SourceLocation Loc, StringRef Name, unsigned &SwiftParamCount, bool &IsSingleParamInit) {\n // ...\n // Check the number of parameters for a getter/setter.\n if (IsGetter || IsSetter) {\n // ...\n // Subscripts may have additional parameters beyond the expected params for\n // the index.\n if (IsSubscript) {\n // ...\n // A subscript setter must explicitly label its newValue parameter to\n // distinguish it from index parameters.\n if (IsSetter) {\n if (!NewValueLocation) {\n S.Diag(Loc, diag::warn_attr_swift_name_subscript_setter_no_newValue) << AL;"}},
[l]={
[Fb]={"clang/test/SemaObjC/attr-swift_name.m:122:83: warning: \'__swift_name__\' attribute for \'subscript\' setter must have a \'newValue:\' parameter [-Wswift-name-attribute]"}
}
},
["warn_attribute_address_multiple_identical_qualifiers"]={
[j]={"duplicate-decl-specifier"},
[k]="duplicate-decl-specifier",
[g]={{nil,F,"warn_attribute_address_multiple_identical_qualifiers"}},
[b]={{nil,F,"multiple identical address spaces specified for type"}},
[c]={{nil,F,"multiple identical address spaces specified for type"}},
[d]=m,
[e]="multiple identical address spaces specified for type",
[f]=" \\[(?:\\-Werror,)?\\-Wduplicate\\-decl\\-specifier[^\\]]*\\]",
[h]={{nil,F,n}},
[a]={"f29d777f847b",1529483484,"[Sema] Allow creating types with multiple of the same addrspace.","[Sema] Allow creating types with multiple of the same addrspace.\n\nSummary:\nThe comment with the OpenCL clause about this clearly\nsays: \"No type shall be qualified by qualifiers for\ntwo or more different address spaces.\"\n\nThis must mean that two or more qualifiers for the\n_same_ address space is allowed. However, it is\nlikely unintended by the programmer, so emit a\nwarning.\n\nFor dependent address space types, reject them like\nbefore since we cannot know what the address space\nwill be.\n\nPatch by Bevin Hansson (ebevhan).\n\nReviewers: Anastasia\n\nReviewed By: Anastasia\n\nSubscribers: bader, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D47630\n\nllvm-svn: 335103"},
[i]={{lb,4629,"// Diagnose whether this is a case with the multiple addr spaces.\n// Returns true if this is an invalid case.\n// ISO/IEC TR 18037 S5.3 (amending C99 6.7.3): \"No type shall be qualified\n// by qualifiers for two or more different address spaces.\"\nstatic bool DiagnoseMultipleAddrSpaceAttributes(Sema &S, LangAS ASOld, LangAS ASNew, SourceLocation AttrLoc) {\n if (ASOld != LangAS::Default) {\n // ...\n S.Diag(AttrLoc, diag::warn_attribute_address_multiple_identical_qualifiers);"}},
[l]={
["clang/test/Sema/address_spaces.c"]={"clang/test/Sema/address_spaces.c:17:13: warning: multiple identical address spaces specified for type [-Wduplicate-decl-specifier]"}
}
},
["warn_attribute_after_definition_ignored"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_after_definition_ignored",
[b]="attribute %0 after definition is ignored",
[c]="attribute A after definition is ignored",
[d]=m,
[e]="attribute (.*?) after definition is ignored",
[f]=y,
[h]=n,
[a]={"06e1b13209a8",1342067550,"Ignore visibility attributes after definitions. This matches newer (4.7) gcc\'s","Ignore visibility attributes after definitions. This matches newer (4.7) gcc\'s\nbehavior and is the first step in fixing pr13338.\n\nllvm-svn: 160104"},
[i]={{C,10383,"void Sema::ActOnFinishCXXMemberSpecification(Scope *S, SourceLocation RLoc, Decl *TagDecl, SourceLocation LBrac, SourceLocation RBrac, const ParsedAttributesView &AttrList) {\n // ...\n for (const ParsedAttr &AL : AttrList) {\n // ...\n Diag(AL.getLoc(), diag::warn_attribute_after_definition_ignored) << AL;"}},
[l]={
["clang/test/SemaCXX/attr-visibility.cpp"]={"clang/test/SemaCXX/attr-visibility.cpp:20:16: warning: attribute \'visibility\' after definition is ignored [-Wignored-attributes]"}
}
},
["warn_attribute_argument_n_negative"]={
[j]={"cuda-compat"},
[k]="cuda-compat",
[g]="warn_attribute_argument_n_negative",
[b]="%0 attribute parameter %1 is negative and will be ignored",
[c]="A attribute parameter B is negative and will be ignored",
[d]=m,
[e]="(.*?) attribute parameter (.*?) is negative and will be ignored",
[f]=" \\[(?:\\-Werror,)?\\-Wcuda\\-compat[^\\]]*\\]",
[h]=n,
[a]={"7093e4064116",1429656954,"[cuda] Allow using integral non-type template parameters as launch_bounds attribute arguments.","[cuda] Allow using integral non-type template parameters as launch_bounds attribute arguments.\n\n - Changed CUDALaunchBounds arguments from integers to Expr* so they can\n be saved in AST for instantiation.\n - Added support for template instantiation of launch_bounds attrubute.\n - Moved evaluation of launch_bounds arguments to NVPTXTargetCodeGenInfo::\n SetTargetAttributes() where it can be done after template instantiation.\n - Added a warning on negative launch_bounds arguments.\n - Amended test cases.\n\nDifferential Revision: http://reviews.llvm.org/D8985\n\nllvm-svn: 235452"},
[i]={{o,5624,"// Checks whether an argument of launch_bounds attribute is\n// acceptable, performs implicit conversion to Rvalue, and returns\n// non-nullptr Expr result on success. Otherwise, it returns nullptr\n// and may output an error.\nstatic Expr *makeLaunchBoundsArgExpr(Sema &S, Expr *E, const CUDALaunchBoundsAttr &AL, const unsigned Idx) {\n // ...\n if (*I < 0)\n S.Diag(E->getExprLoc(), diag::warn_attribute_argument_n_negative) << &AL << Idx << E->getSourceRange();"}},
[l]={
["clang/test/SemaCUDA/launch_bounds.cu"]={"clang/test/SemaCUDA/launch_bounds.cu:12:19: warning: \'launch_bounds\' attribute parameter 0 is negative and will be ignored [-Wcuda-compat]","clang/test/SemaCUDA/launch_bounds.cu:13:24: warning: \'launch_bounds\' attribute parameter 1 is negative and will be ignored [-Wcuda-compat]"}
}
},
["warn_attribute_cmse_entry_static"]={
[j]={x,q},
[k]=q,
[g]={{nil,t,"warn_attribute_cmse_entry_static"}},
[b]={{nil,t,"\'cmse_nonsecure_entry\' cannot be applied to functions with internal linkage"}},
[c]={{nil,t,"\'cmse_nonsecure_entry\' cannot be applied to functions with internal linkage"}},
[d]=m,
[e]="\'cmse_nonsecure_entry\' cannot be applied to functions with internal linkage",
[f]=y,
[h]={{nil,t,n}},
[a]={"931fcd3ba011",1576908663,"[WebAssembly] Improve clang diagnostics for wasm attributes","[WebAssembly] Improve clang diagnostics for wasm attributes\n\nThis patch addresses the review comments on r352930:\n\n - Removes redundant diagnostic checking code\n - Removes errnoneous use of diag::err_alias_is_definition, which\n turned out to be ineffective anyway since functions can be defined later\n in the translation unit and avoid detection.\n - Adds a test for various invalid cases for import_name and import_module.\n\nDifferential Revision: https://reviews.llvm.org/D59520"},
[i]={{o,2152,"static void handleCmseNSEntryAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!FD->isExternallyVisible()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_cmse_entry_static);"}},
[l]={
["clang/test/Sema/arm-cmse.c"]={"clang/test/Sema/arm-cmse.c:17:38: warning: \'cmse_nonsecure_entry\' cannot be applied to functions with internal linkage [-Wignored-attributes]"}
}
},
["warn_attribute_dll_instantiated_base_class"]={
[j]={"unsupported-dll-base-class-template"},
[k]="unsupported-dll-base-class-template",
[g]="warn_attribute_dll_instantiated_base_class",
[b]="propagating dll attribute to %select{already instantiated|explicitly specialized}0 base class template without dll attribute is not supported",
[c]={{nil,nil,{"propagating dll attribute to ",{"already instantiated","explicitly specialized"}," base class template without dll attribute is not supported"}}},
[d]=m,
[e]="propagating dll attribute to (?:already instantiated|explicitly specialized) base class template without dll attribute is not supported",
[f]=" \\[(?:\\-Werror,)?\\-Wunsupported\\-dll\\-base\\-class\\-template[^\\]]*\\]",
[h]=n,
[a]={"9bea9cc73bd0",1403720757,"MS ABI: Propagate class-level DLL attributes to class template specialization bases (PR11170)","MS ABI: Propagate class-level DLL attributes to class template specialization bases (PR11170)\n\nConsider the following code:\n\n template <typename T> class Base {};\n class __declspec(dllexport) class Derived : public Base<int> {}\n\nWhen the base of an exported or imported class is a class template\nspecialization, MSVC will propagate the dll attribute to the base.\nIn the example code, Base<int> becomes a dllexported class.\n\nThis commit makes Clang do the proopagation when the base hasn\'t been\ninstantiated yet, and warns about it being unsupported otherwise.\nThis is different from MSVC, which allows changing a specialization\nback and forth between dllimport and dllexport and seems to let the\nlast one win. Changing the dll attribute after instantiation would be\nhard for us, and doesn\'t seem to come up in practice, so I think this\nis a reasonable limitation to have.\n\nMinGW doesn\'t do this kind of propagation.\n\nDifferential Revision: http://reviews.llvm.org/D4264\n\nllvm-svn: 211725"},
[i]={{C,6656,"/// Perform propagation of DLL attributes from a derived class to a\n/// templated base class for MS compatibility.\nvoid Sema::propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {\n // ...\n Diag(BaseLoc, diag::warn_attribute_dll_instantiated_base_class) << BaseTemplateSpec->isExplicitSpecialization();"}},
[l]={
["clang/test/SemaCXX/dllexport.cpp"]={"clang/test/SemaCXX/dllexport.cpp:501:80: warning: propagating dll attribute to explicitly specialized base class template without dll attribute is not supported [-Wunsupported-dll-base-class-template]","clang/test/SemaCXX/dllexport.cpp:513:81: warning: propagating dll attribute to already instantiated base class template without dll attribute is not supported [-Wunsupported-dll-base-class-template]"}
}
},
["warn_attribute_dll_redeclaration"]={
[j]={"dll-attribute-on-redeclaration"},
[k]="dll-attribute-on-redeclaration",
[g]="warn_attribute_dll_redeclaration",
[b]="redeclaration of %q0 should not add %q1 attribute",
[c]="redeclaration of A should not add B attribute",
[d]=m,
[e]="redeclaration of (.*?) should not add (.*?) attribute",
[f]=" \\[(?:\\-Werror,)?\\-Wdll\\-attribute\\-on\\-redeclaration[^\\]]*\\]",
[h]=n,
[a]={"dd96db2c034c",1409174860,"Allow adding dll attributes on certain redecls with a warning if the decl hasn\'t been used yet (PR20...","Allow adding dll attributes on certain redecls with a warning if the decl hasn\'t been used yet (PR20746)\n\nThis shouldn\'t really be allowed, but it comes up in real code (see PR). As\nlong as the decl hasn\'t been used there\'s no technical difficulty in supporting\nit, so downgrade the error to a warning.\n\nDifferential Revision: http://reviews.llvm.org/D5087\n\nllvm-svn: 216619"},
[i]={{H,7092,"static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition) {\n // ...\n if (AddsAttr && !IsSpecialization && !OldDecl->isImplicit()) {\n // ...\n unsigned DiagID = JustWarn ? diag::warn_attribute_dll_redeclaration : diag::err_attribute_dll_redeclaration;"}},
[l]={
["clang/test/Sema/dllexport.c"]={"clang/test/Sema/dllexport.c:52:34: warning: redeclaration of \'GlobalRedecl4\' should not add \'dllexport\' attribute [-Wdll-attribute-on-redeclaration]","clang/test/Sema/dllexport.c:112:28: warning: redeclaration of \'redecl6\' should not add \'dllexport\' attribute [-Wdll-attribute-on-redeclaration]"}
}
},
["warn_attribute_dllexport_explicit_instantiation_decl"]={
[j]={"dllexport-explicit-instantiation-decl"},
[k]="dllexport-explicit-instantiation-decl",
[g]="warn_attribute_dllexport_explicit_instantiation_decl",
[b]="explicit instantiation declaration should not be \'dllexport\'",
[c]="explicit instantiation declaration should not be \'dllexport\'",
[d]=m,
[e]="explicit instantiation declaration should not be \'dllexport\'",
[f]=" \\[(?:\\-Werror,)?\\-Wdllexport\\-explicit\\-instantiation\\-decl[^\\]]*\\]",
[h]=n,
[a]={"fd76d9136601",1421356710,"Warn about dllexported explicit class template instantiation declarations (PR22035)","Warn about dllexported explicit class template instantiation declarations (PR22035)\n\nClang would previously become confused and crash here.\n\nIt does not make a lot of sense to export these, so warning seems appropriate.\n\nMSVC will export some member functions for this kind of specializations, whereas\nMinGW ignores the dllexport-edness. The latter behaviour seems better.\n\nDifferential Revision: http://reviews.llvm.org/D6984\n\nllvm-svn: 226208"},
[i]={{mc,9995,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n // ...\n if (TSK == TSK_ExplicitInstantiationDeclaration && !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {\n // Check for dllexport class template instantiation declarations,\n // except for MinGW mode.\n for (const ParsedAttr &AL : Attr) {\n if (AL.getKind() == ParsedAttr::AT_DLLExport) {\n Diag(ExternLoc, diag::warn_attribute_dllexport_explicit_instantiation_decl);"},{mc,10003,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n // ...\n if (TSK == TSK_ExplicitInstantiationDeclaration && !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {\n // ...\n if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {\n Diag(ExternLoc, diag::warn_attribute_dllexport_explicit_instantiation_decl);"}},
[l]={
["clang/test/SemaCXX/dllexport.cpp"]={"clang/test/SemaCXX/dllexport.cpp:383:1: warning: explicit instantiation declaration should not be \'dllexport\' [-Wdllexport-explicit-instantiation-decl]","clang/test/SemaCXX/dllexport.cpp:418:1: warning: explicit instantiation declaration should not be \'dllexport\' [-Wdllexport-explicit-instantiation-decl]","clang/test/SemaCXX/dllexport.cpp:425:1: warning: explicit instantiation declaration should not be \'dllexport\' [-Wdllexport-explicit-instantiation-decl]"}
}
},
["warn_attribute_dllexport_explicit_instantiation_def"]={
[j]={x,q},
[k]=q,
[g]={{nil,B,"warn_attribute_dllexport_explicit_instantiation_def"}},
[b]={{nil,B,"\'dllexport\' attribute ignored on explicit instantiation definition"}},
[c]={{nil,B,"\'dllexport\' attribute ignored on explicit instantiation definition"}},
[d]=m,
[e]="\'dllexport\' attribute ignored on explicit instantiation definition",
[f]=y,
[h]={{nil,B,n}},
[a]={"5be69bc68a65",1556266191,"[MinGW] Fix dllexport of explicit template instantiation","[MinGW] Fix dllexport of explicit template instantiation\n\nContrary to MSVC, GCC/MinGW needs to have the dllexport attribute\non the template instantiation declaration, not on the definition.\n\nPreviously clang never marked explicit template instantiations as\ndllexport in MinGW mode, if the instantiation had a previous\ndeclaration, regardless of where the attribute was placed. This\nmakes Clang behave like GCC in this regard, and allows using the\nsame attribute form for both MinGW compilers.\n\nThis fixes PR40256.\n\nDifferential Revision: https://reviews.llvm.org/D61118\n\nllvm-svn: 359285"},
[i]={{mc,10059,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n // ...\n if (TSK == TSK_ExplicitInstantiationDefinition && PrevDecl != nullptr && Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {\n // Check for dllexport class template instantiation definitions in MinGW\n // mode, if a previous declaration of the instantiation was seen.\n for (const ParsedAttr &AL : Attr) {\n if (AL.getKind() == ParsedAttr::AT_DLLExport) {\n Diag(AL.getLoc(), diag::warn_attribute_dllexport_explicit_instantiation_def);"}},
[l]={
["clang/test/CodeGenCXX/mingw-template-dllexport.cpp"]={"clang/test/CodeGenCXX/mingw-template-dllexport.cpp:23:27: warning: \'dllexport\' attribute ignored on explicit instantiation definition [-Wignored-attributes]"}
}
},
["warn_attribute_dllimport_static_field_definition"]={
[j]={"dllimport-static-field-def"},
[k]="dllimport-static-field-def",
[g]="warn_attribute_dllimport_static_field_definition",
[b]="definition of dllimport static field",
[c]="definition of dllimport static field",
[d]=m,
[e]="definition of dllimport static field",
[f]=" \\[(?:\\-Werror,)?\\-Wdllimport\\-static\\-field\\-def[^\\]]*\\]",
[h]=n,
[a]={"e9af3164237f",1401841121,"Downgrade \"definition of dllimport static field\" error to warning for class templates (PR19902)","Downgrade \"definition of dllimport static field\" error to warning for class templates (PR19902)\n\nThis allows us to compile the following kind of code, which occurs in MSVC\nheaders:\n\n template <typename> struct S {\n __declspec(dllimport) static int x;\n };\n template <typename T> int S<T>::x;\n\nThe definition works similarly to a dllimport inline function definition and\ngets available_externally linkage.\n\nDifferential Revision: http://reviews.llvm.org/D3998\n\nllvm-svn: 210141"},
[i]={{H,14445,"/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform\n/// any semantic actions necessary after any initializer has been attached.\nvoid Sema::FinalizeDeclaration(Decl *ThisDecl) {\n // ...\n // Imported static data members cannot be defined out-of-line.\n if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {\n if (VD->isStaticDataMember() && VD->isOutOfLine() && VD->isThisDeclarationADefinition()) {\n // ...\n Diag(VD->getLocation(), IsClassTemplateMember ? diag::warn_attribute_dllimport_static_field_definition : diag::err_attribute_dllimport_static_field_definition);"}},
[l]={
["clang/test/SemaCXX/dllimport.cpp"]={"clang/test/SemaCXX/dllimport.cpp:1237:61: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1238:61: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1289:65: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1292:65: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1404:80: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1405:80: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1452:87: warning: definition of dllimport static field [-Wdllimport-static-field-def]","clang/test/SemaCXX/dllimport.cpp:1455:87: warning: definition of dllimport static field [-Wdllimport-static-field-def]"}
}
},
["warn_attribute_has_no_effect_on_compile_time_if"]={
[j]={x,q},
[k]=q,
[g]={{nil,z,"warn_attribute_has_no_effect_on_compile_time_if"}},
[b]={{nil,z,"attribute %0 has no effect when annotating an \'if %select{constexpr|consteval}1\' statement"}},
[c]={{nil,z,{"attribute A has no effect when annotating an \'if ",{"constexpr","consteval"},"\' statement"}}},
[d]=m,
[e]="attribute (.*?) has no effect when annotating an \'if (?:constexpr|consteval)\' statement",
[f]=y,
[h]={{nil,z,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{X,909,"StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *thenStmt, SourceLocation ElseLoc, Stmt *elseStmt) {\n // ...\n if (ConstevalOrNegatedConsteval || StatementKind == IfStatementKind::Constexpr) {\n auto DiagnoseLikelihood = [&](const Stmt *S) {\n if (const Attr *A = Stmt::getLikelihoodAttr(S)) {\n Diags.Report(A->getLocation(), diag::warn_attribute_has_no_effect_on_compile_time_if) << A << ConstevalOrNegatedConsteval << A->getRange();"}},
[l]={
["clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp"]={"clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp:40:18: warning: attribute \'likely\' has no effect when annotating an \'if consteval\' statement [-Wignored-attributes]","clang/test/CXX/stmt.stmt/stmt.select/stmt.if/p4.cpp:45:10: warning: attribute \'unlikely\' has no effect when annotating an \'if consteval\' statement [-Wignored-attributes]"}
}
},
["warn_attribute_has_no_effect_on_infinite_loop"]={
[j]={x,q},
[k]=q,
[g]={{nil,p,"warn_attribute_has_no_effect_on_infinite_loop"}},
[b]={{nil,p,"attribute %0 has no effect when annotating an infinite loop"}},
[c]={{nil,p,"attribute A has no effect when annotating an infinite loop"}},
[d]=m,
[e]="attribute (.*?) has no effect when annotating an infinite loop",
[f]=y,
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{"clang/lib/CodeGen/CGStmt.cpp",933,"void CodeGenFunction::EmitWhileStmt(const WhileStmt &S, ArrayRef<const Attr *> WhileAttrs) {\n // ...\n if (EmitBoolCondBranch) {\n // ...\n } else if (const Attr *A = Stmt::getLikelihoodAttr(S.getBody())) {\n CGM.getDiags().Report(A->getLocation(), diag::warn_attribute_has_no_effect_on_infinite_loop) << A << A->getRange();"}},
[l]={
["clang/test/CodeGenCXX/attr-likelihood-iteration-stmt.cpp"]={"clang/test/CodeGenCXX/attr-likelihood-iteration-stmt.cpp:63:14: warning: attribute \'likely\' has no effect when annotating an infinite loop [-Wignored-attributes]"}
}
},
["warn_attribute_iboutlet"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_iboutlet",
[b]="%0 attribute can only be applied to instance variables or properties",
[c]="A attribute can only be applied to instance variables or properties",
[d]=m,
[e]="(.*?) attribute can only be applied to instance variables or properties",
[f]=y,
[h]=n,
[a]={"d68ec818c351",1296802456,"Downgrade error about attribute \'iboutlet\' and \'ibaction\' being applied to anything but a instance m...","Downgrade error about attribute \'iboutlet\' and \'ibaction\' being applied to anything but a instance method to a warning.\n\nllvm-svn: 124858"},
[i]={{o,1487,"static bool checkIBOutletCommon(Sema &S, Decl *D, const ParsedAttr &AL) {\n // The IBOutlet/IBOutletCollection attributes only apply to instance\n // variables or properties of Objective-C classes. The outlet must also\n // have an object reference type.\n if (const auto *VD = dyn_cast<ObjCIvarDecl>(D)) {\n // ...\n } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {\n // ...\n } else {\n S.Diag(AL.getLoc(), diag::warn_attribute_iboutlet) << AL;"}}
},
["warn_attribute_ignored"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_ignored",
[b]="%0 attribute ignored",
[c]="A attribute ignored",
[d]=m,
[e]="(.*?) attribute ignored",
[f]=y,
[h]={{nil,D,O},{z,nil,n}},
[a]={K,1236199783,J,I},
[i]={{Tb,3342,"/// ParseDeclarationSpecifiers\n/// declaration-specifiers: [C99 6.7]\n/// storage-class-specifier declaration-specifiers[opt]\n/// type-specifier declaration-specifiers[opt]\n/// [C99] function-specifier declaration-specifiers[opt]\n/// [C11] alignment-specifier declaration-specifiers[opt]\n/// [GNU] attributes declaration-specifiers[opt]\n/// [Clang] \'__module_private__\' declaration-specifiers[opt]\n/// [ObjC1] \'__kindof\' declaration-specifiers[opt]\n///\n/// storage-class-specifier: [C99 6.7.1]\n/// \'typedef\'\n/// \'extern\'\n/// \'static\'\n/// \'auto\'\n/// \'register\'\n/// [C++] \'mutable\'\n/// [C++11] \'thread_local\'\n/// [C11] \'_Thread_local\'\n/// [GNU] \'__thread\'\n/// function-specifier: [C99 6.7.4]\n/// [C99] \'inline\'\n/// [C++] \'virtual\'\n/// [C++] \'explicit\'\n/// [OpenCL] \'__kernel\'\n/// \'friend\': [C++ dcl.friend]\n/// \'constexpr\': [C++0x dcl.constexpr]\nvoid Parser::ParseDeclarationSpecifiers(DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSContext, LateParsedAttrList *LateAttrs, ImplicitTypenameContext AllowImplicitTypename) {\n // ...\n while (true) {\n // ...\n DoneWithDeclSpec:\n if (!AttrsLastTime)\n // ...\n else {\n // Reject C++11 / C2x attributes that aren\'t type attributes.\n for (const ParsedAttr &PA : attrs) {\n // ...\n // GCC ignores this attribute when placed on the DeclSpec in [[]]\n // syntax, so we do the same.\n if (PA.getKind() == ParsedAttr::AT_VectorSize) {\n Diag(PA.getLoc(), diag::warn_attribute_ignored) << PA;"},{"clang/lib/Parse/ParseStmt.cpp",343,"#include \"clang/Basic/TransformTypeTraits.def\"\n // ...\n case tok::kw_asm: {\n for (const ParsedAttr &AL : CXX11Attrs)\n // ...\n (AL.isRegularKeywordAttribute() ? Diag(AL.getRange().getBegin(), diag::err_keyword_not_allowed) : Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored)) << AL;"},{"clang/lib/Sema/ParsedAttr.cpp",184,"bool ParsedAttr::diagnoseLangOpts(Sema &S) const {\n // ...\n S.Diag(getLoc(), diag::warn_attribute_ignored) << *this;"},{o,1428,"static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (auto *TD = dyn_cast<TagDecl>(D))\n // ...\n else if (auto *FD = dyn_cast<FieldDecl>(D)) {\n // ...\n } else\n S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;"},{o,2897,"static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL, bool isTypeVisibility) {\n // Visibility attributes don\'t mean anything on a typedef.\n if (isa<TypedefNameDecl>(D)) {\n S.Diag(AL.getRange().getBegin(), diag::warn_attribute_ignored) << AL;"},{o,3846,"/// Handle __attribute__((init_priority(priority))) attributes based on\n/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html\nstatic void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (!S.getLangOpts().CPlusPlus) {\n S.Diag(AL.getLoc(), diag::warn_attribute_ignored) << AL;"},{o,4887,"AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident) {\n if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {\n Diag(CI.getLoc(), diag::warn_attribute_ignored) << Ident;"},{o,4943,"MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI) {\n if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {\n Diag(CI.getLoc(), diag::warn_attribute_ignored) << \"\'minsize\'\";"},{o,4973,"OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI) {\n if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {\n Diag(Inline->getLocation(), diag::warn_attribute_ignored) << Inline;"},{o,4978,"OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI) {\n // ...\n if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {\n Diag(MinSize->getLocation(), diag::warn_attribute_ignored) << MinSize;"},{o,8006,"DLLImportAttr *Sema::mergeDLLImportAttr(Decl *D, const AttributeCommonInfo &CI) {\n if (D->hasAttr<DLLExportAttr>()) {\n Diag(CI.getLoc(), diag::warn_attribute_ignored) << \"\'dllimport\'\";"},{o,8019,"DLLExportAttr *Sema::mergeDLLExportAttr(Decl *D, const AttributeCommonInfo &CI) {\n if (DLLImportAttr *Import = D->getAttr<DLLImportAttr>()) {\n Diag(Import->getLocation(), diag::warn_attribute_ignored) << Import;"},{o,8032,"static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) {\n if (isa<ClassTemplatePartialSpecializationDecl>(D) && (S.Context.getTargetInfo().shouldDLLImportComdatSymbols())) {\n S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored) << A;"},{lb,7805,"/// Process an individual function attribute. Returns true to\n/// indicate that the attribute was handled, false if it wasn\'t.\nstatic bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n // ...\n if (attr.getKind() == ParsedAttr::AT_CmseNSCall) {\n // ...\n // Ignore if we don\'t have CMSE enabled.\n if (!S.getLangOpts().Cmse) {\n S.Diag(attr.getLoc(), diag::warn_attribute_ignored) << attr;"},{lb,8664,"static void processTypeAttrs(TypeProcessingState &state, QualType &type, TypeAttrLocation TAL, const ParsedAttributesView &attrs) {\n // ...\n for (ParsedAttr &attr : AttrsCopy) {\n // ...\n case ParsedAttr::AT_NoDeref: {\n // FIXME: `noderef` currently doesn\'t work correctly in [[]] syntax.\n // See https://github.com/llvm/llvm-project/issues/55790 for details.\n // For the time being, we simply emit a warning that the attribute is\n // ignored.\n if (attr.isStandardAttributeSyntax()) {\n state.getSema().Diag(attr.getLoc(), diag::warn_attribute_ignored) << attr;"}},
[l]={
["clang/test/Sema/pragma-attribute.c"]={"clang/test/Sema/pragma-attribute.c:31:16: warning: \'always_inline\' attribute ignored [-Wignored-attributes]","clang/test/Sema/pragma-attribute.c:36:16: warning: \'always_inline\' attribute ignored [-Wignored-attributes]"}
}
},
["warn_attribute_ignored_for_field_of_type"]={
[j]={x,q},
[k]=q,
[g]={{nil,N,"warn_attribute_ignored_for_field_of_type"}},
[b]={{nil,N,"%0 attribute ignored for field of type %1"}},
[c]={{nil,N,"A attribute ignored for field of type B"}},
[d]=m,
[e]="(.*?) attribute ignored for field of type (.*?)",
[f]=y,
[h]={{nil,N,n}},
[a]={K,1236199783,J,I},
[i]={{o,1415,"static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (auto *TD = dyn_cast<TagDecl>(D))\n // ...\n else if (auto *FD = dyn_cast<FieldDecl>(D)) {\n // ...\n if (S.getASTContext().getTargetInfo().getTriple().isPS()) {\n if (BitfieldByteAligned)\n // ...\n S.Diag(AL.getLoc(), diag::warn_attribute_ignored_for_field_of_type) << AL << FD->getType();"}},
[l]={
["clang/test/Sema/struct-packed-align.c"]={"clang/test/Sema/struct-packed-align.c:154:29: warning: \'packed\' attribute ignored for field of type \'char\' [-Wignored-attributes]"}
}
},
["warn_attribute_ignored_no_calls_in_stmt"]={
[j]={x,q},
[k]=q,
[g]={{nil,D,"warn_attribute_ignored_no_calls_in_stmt"}},
[b]={{nil,D,"%0 attribute is ignored because there exists no call expression inside the statement"}},
[c]={{nil,D,"A attribute is ignored because there exists no call expression inside the statement"}},
[d]=m,
[e]="(.*?) attribute is ignored because there exists no call expression inside the statement",
[f]=y,
[h]={{nil,D,n}},
[a]={"f60dc3caa673",1620118562,"[C++20][Modules] Adjust handling of exports of namespaces and using-decls.","[C++20][Modules] Adjust handling of exports of namespaces and using-decls.\n\nThis adjusts the handling for:\n\nexport module M;\n\nexport namespace {};\n\nexport namespace N {};\nexport using namespace N;\n\nIn the first case, we were allowing empty anonymous namespaces\nas part of an extension allowing empty top-level entities, but that seems\ninappropriate in this case, since the linkage would be internal for the\nanonymous namespace. We now report an error for this.\n\nThe second case was producing a warning diagnostic that this was\naccepted as an extension - however the C++20 standard does allow this\nas well-formed.\n\nIn the third case we keep the current practice that this is accepted with a\nwarning (as an extension). The C++20 standard says it\'s an error.\n\nWe also ensure that using decls are only applied to items with external linkage.\n\nThis adjusts error messages for exports involving redeclarations in modules to\nbe more specific about the reason that the decl has been rejected.\n\nDifferential Revision: https://reviews.llvm.org/D122119"},
[i]={{"clang/lib/Sema/SemaStmtAttr.cpp",211,"static Attr *handleNoMergeAttr(Sema &S, Stmt *St, const ParsedAttr &A, SourceRange Range) {\n // ...\n if (!CEF.foundCallExpr() && !CEF.foundAsmStmt()) {\n S.Diag(St->getBeginLoc(), diag::warn_attribute_ignored_no_calls_in_stmt) << A;"},{"clang/lib/Sema/SemaStmtAttr.cpp",238,"template <typename OtherAttr, int DiagIdx> static bool CheckStmtInlineAttr(Sema &SemaRef, const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A) {\n // ...\n if (!CEF.foundCallExpr()) {\n return SemaRef.Diag(CurSt->getBeginLoc(), diag::warn_attribute_ignored_no_calls_in_stmt) << A;"}},
[l]={
["clang/test/Parser/stmt-attributes.m"]={"clang/test/Parser/stmt-attributes.m:31:28: warning: \'nomerge\' attribute is ignored because there exists no call expression inside the statement [-Wignored-attributes]","clang/test/Parser/stmt-attributes.m:37:28: warning: \'nomerge\' attribute is ignored because there exists no call expression inside the statement [-Wignored-attributes]","clang/test/Parser/stmt-attributes.m:51:28: warning: \'nomerge\' attribute is ignored because there exists no call expression inside the statement [-Wignored-attributes]","clang/test/Parser/stmt-attributes.m:54:28: warning: \'nomerge\' attribute is ignored because there exists no call expression inside the statement [-Wignored-attributes]"}
}
},
["warn_attribute_ignored_non_function_pointer"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_ignored_non_function_pointer",
[b]="%0 attribute is ignored because %1 is not a function pointer",
[c]="A attribute is ignored because B is not a function pointer",
[d]=m,
[e]="(.*?) attribute is ignored because (.*?) is not a function pointer",
[f]=y,
[h]=n,
[a]={sb,1625925174,rb,vb},
[i]={{o,8382,"static void handleNoMergeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (VDecl && !VDecl->isFunctionPointerType()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_ignored_non_function_pointer) << AL << VDecl;"}},
[l]={
["clang/test/Parser/stmt-attributes.c"]={"clang/test/Parser/stmt-attributes.c:91:16: warning: \'nomerge\' attribute is ignored because \'i\' is not a function pointer [-Wignored-attributes]"}
}
},
["warn_attribute_ignored_on_inline"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_ignored_on_inline",
[b]="%0 attribute ignored on inline function",
[c]="A attribute ignored on inline function",
[d]=m,
[e]="(.*?) attribute ignored on inline function",
[f]=y,
[h]=n,
[a]={"606bd6dcc547",1415024685,"Don\'t dllimport inline functions when targeting MinGW (PR21366)","Don\'t dllimport inline functions when targeting MinGW (PR21366)\n\nIt turns out that MinGW never dllimports of exports inline functions.\nThis means that code compiled with Clang would fail to link with\nMinGW-compiled libraries since we might try to import functions that\nare not imported.\n\nTo fix this, make Clang never dllimport inline functions when targeting\nMinGW.\n\nllvm-svn: 221154"},
[i]={{o,8040,"static void handleDLLAttr(Sema &S, Decl *D, const ParsedAttr &A) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n if (FD->isInlined() && A.getKind() == ParsedAttr::AT_DLLImport && !(S.Context.getTargetInfo().shouldDLLImportComdatSymbols())) {\n // ...\n S.Diag(A.getRange().getBegin(), diag::warn_attribute_ignored_on_inline) << A;"}},
[l]={
["clang/test/Sema/dllimport.c"]={"clang/test/Sema/dllimport.c:172:12: warning: \'dllimport\' attribute ignored on inline function [-Wignored-attributes]","clang/test/Sema/dllimport.c:173:28: warning: \'dllimport\' attribute ignored on inline function [-Wignored-attributes]","clang/test/Sema/dllimport.c:217:12: warning: \'dllimport\' attribute ignored on inline function [-Wignored-attributes]"}
}
},
["warn_attribute_ignored_on_non_definition"]={
[j]={x,q},
[k]=q,
[g]={{nil,w,"warn_attribute_ignored_on_non_definition"}},
[b]={{nil,w,"%0 attribute ignored on a non-definition declaration"}},
[c]={{nil,w,"A attribute ignored on a non-definition declaration"}},
[d]=m,
[e]="(.*?) attribute ignored on a non\\-definition declaration",
[f]=y,
[h]={{nil,w,n}},
[a]={hb,1590001902,ib,kb},
[i]={{H,14471,"/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform\n/// any semantic actions necessary after any initializer has been attached.\nvoid Sema::FinalizeDeclaration(Decl *ThisDecl) {\n // ...\n if (UsedAttr *Attr = VD->getAttr<UsedAttr>()) {\n if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {\n Diag(Attr->getLocation(), diag::warn_attribute_ignored_on_non_definition) << Attr;"},{H,14478,"/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform\n/// any semantic actions necessary after any initializer has been attached.\nvoid Sema::FinalizeDeclaration(Decl *ThisDecl) {\n // ...\n if (RetainAttr *Attr = VD->getAttr<RetainAttr>()) {\n if (!Attr->isInherited() && !VD->isThisDeclarationADefinition()) {\n Diag(Attr->getLocation(), diag::warn_attribute_ignored_on_non_definition) << Attr;"}},
[l]={
["clang/test/Sema/attr-used.c"]={"clang/test/Sema/attr-used.c:3:30: warning: \'used\' attribute ignored on a non-definition declaration [-Wignored-attributes]","clang/test/Sema/attr-used.c:4:42: warning: \'used\' attribute ignored on a non-definition declaration [-Wignored-attributes]"}
}
},
["warn_attribute_invalid_on_definition"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_invalid_on_definition",
[b]="\'%0\' attribute cannot be specified on a definition",
[c]="\'A\' attribute cannot be specified on a definition",
[d]=m,
[e]="\'(.*?)\' attribute cannot be specified on a definition",
[f]=y,
[h]=n,
[a]={"52d598e24269",1369086809,"Warn on and drop dllimport attrs from variable definitions","Warn on and drop dllimport attrs from variable definitions\n\nAsmPrinter::EmitLinkage() does not handle dllimport linkage. The LLVM\nverifier should also be fixed to reject this.\n\nllvm-svn: 182320"},
[i]={{o,3195,"static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!D->canBeWeakImported(isDef)) {\n if (isDef)\n S.Diag(AL.getLoc(), diag::warn_attribute_invalid_on_definition) << \"weak_import\";"}},
[l]={
["clang/test/Sema/2009-03-09-WeakDeclarations-1.c"]={"clang/test/Sema/2009-03-09-WeakDeclarations-1.c:8:38: warning: \'weak_import\' attribute cannot be specified on a definition [-Wignored-attributes]","clang/test/Sema/2009-03-09-WeakDeclarations-1.c:9:50: warning: \'weak_import\' attribute cannot be specified on a definition [-Wignored-attributes]"}
}
},
["warn_attribute_no_builtin_invalid_builtin_name"]={
[j]={"invalid-no-builtin-names"},
[k]="invalid-no-builtin-names",
[g]={{nil,s,"warn_attribute_no_builtin_invalid_builtin_name"}},
[b]={{nil,s,"\'%0\' is not a valid builtin name for %1"}},
[c]={{nil,s,"\'A\' is not a valid builtin name for B"}},
[d]=m,
[e]="\'(.*?)\' is not a valid builtin name for (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Winvalid\\-no\\-builtin\\-names[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"bd8791610948",1569403888,"[clang] Add no_builtin attribute","[clang] Add no_builtin attribute\n\nSummary:\nThis is a follow up on https://reviews.llvm.org/D61634\nThis patch is simpler and only adds the no_builtin attribute.\n\nReviewers: tejohnson, courbet, theraven, t.p.northover, jdoerfert\n\nSubscribers: mgrang, cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D68028"},
[i]={{o,1153,"static void handleNoBuiltinAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n // Add current attributes.\n if (AL.getNumArgs() == 0)\n // ...\n else\n for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {\n // ...\n if (Builtin::Context::isBuiltinFunc(BuiltinName))\n // ...\n else\n S.Diag(LiteralLoc, diag::warn_attribute_no_builtin_invalid_builtin_name) << BuiltinName << AL;"}},
[l]={
["clang/test/Sema/no-builtin.cpp"]={"clang/test/Sema/no-builtin.cpp:18:50: warning: \'not_a_builtin\' is not a valid builtin name for \'no_builtin\' [-Winvalid-no-builtin-names]"}
}
},
["warn_attribute_no_decl"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_no_decl",
[b]="attribute %0 ignored, because it is not attached to a declaration",
[c]="attribute A ignored, because it is not attached to a declaration",
[d]=m,
[e]="attribute (.*?) ignored, because it is not attached to a declaration",
[f]=y,
[h]=db,
[a]={"71d610329554",1330727390,"Issue warning when late-parsed attributes have no declaration.","Issue warning when late-parsed attributes have no declaration.\n\nllvm-svn: 151947"},
[i]={{"clang/lib/Parse/ParseCXXInlineMethods.cpp",767,"/// Finish parsing an attribute for which parsing was delayed.\n/// This will be called at the end of parsing a class declaration\n/// for each LateParsedAttribute. We consume the saved tokens and\n/// create an attribute with the arguments filled in. We add this\n/// to the Attribute list for the decl.\nvoid Parser::ParseLexedAttribute(LateParsedAttribute &LA, bool EnterScope, bool OnDefinition) {\n // ...\n if (LA.Decls.size() > 0) {\n // ...\n } else {\n Diag(Tok, diag::warn_attribute_no_decl) << LA.AttrName.getName();"}},
[l]={
["clang/test/Parser/cxx-attributes.cpp"]={"clang/test/Parser/cxx-attributes.cpp:17:69: warning: attribute locks_excluded ignored, because it is not attached to a declaration [-Wignored-attributes]"}
}
},
["warn_attribute_nonnull_no_pointers"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_nonnull_no_pointers",
[b]="\'nonnull\' attribute applied to function with no pointer arguments",
[c]="\'nonnull\' attribute applied to function with no pointer arguments",
[d]=m,
[e]="\'nonnull\' attribute applied to function with no pointer arguments",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{o,1618,"static void handleNonNullAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n // If no arguments were specified to __attribute__((nonnull)) then all pointer\n // arguments have a nonnull attribute; warn if there aren\'t any. Skip this\n // check if the attribute came from a macro expansion or a template\n // instantiation.\n if (NonNullArgs.empty() && AL.getLoc().isFileID() && !S.inTemplateInstantiation()) {\n // ...\n if (!AnyPointers)\n S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_no_pointers);"}},
[l]={
["clang/test/Sema/attr-nonnull.c"]={"clang/test/Sema/attr-nonnull.c:7:30: warning: \'nonnull\' attribute applied to function with no pointer arguments [-Wignored-attributes]"}
}
},
["warn_attribute_nonnull_parm_no_args"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_nonnull_parm_no_args",
[b]="\'nonnull\' attribute when used on parameters takes no arguments",
[c]="\'nonnull\' attribute when used on parameters takes no arguments",
[d]=m,
[e]="\'nonnull\' attribute when used on parameters takes no arguments",
[f]=y,
[h]=n,
[a]={"9aedc159ef4c",1389939896,"Enhance attribute \'nonnull\' to be applicable to parameters directly (infix).","Enhance attribute \'nonnull\' to be applicable to parameters directly (infix).\n\nThis allows the following syntax:\n\n void baz(__attribute__((nonnull)) const char *str);\n\ninstead of:\n\n void baz(const char *str) __attribute__((nonnull(1)));\n\nThis also extends to Objective-C methods.\n\nThe checking logic in Sema is not as clean as I would like. Effectively\nnow we need to check both the FunctionDecl/ObjCMethodDecl and the parameters,\nso the point of truth is spread in two places, but the logic isn\'t that\ncumbersome.\n\nImplements <rdar://problem/14691443>.\n\nllvm-svn: 199467"},
[i]={{o,1633,"static void handleNonNullAttrParameter(Sema &S, ParmVarDecl *D, const ParsedAttr &AL) {\n if (AL.getNumArgs() > 0) {\n if (D->getFunctionType()) {\n // ...\n } else {\n S.Diag(AL.getLoc(), diag::warn_attribute_nonnull_parm_no_args) << D->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/nonnull.m"]={"clang/test/SemaObjC/nonnull.m:106:60: warning: \'nonnull\' attribute when used on parameters takes no arguments [-Wignored-attributes]"}
}
},
["warn_attribute_not_on_decl"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_not_on_decl",
[b]="%0 attribute ignored when parsing type",
[c]="A attribute ignored when parsing type",
[d]=m,
[e]="(.*?) attribute ignored when parsing type",
[f]=y,
[h]=n,
[a]={"42856de54283",1317446223,"Hey, maybe we shouldn\'t silently ignore decl attributes","Hey, maybe we shouldn\'t silently ignore decl attributes\non declarators written as types.\n\nllvm-svn: 140931"},
[i]={{o,9621,"/// checkUnusedDeclAttributes - Check a list of attributes to see if it\n/// contains any decl attributes that we should warn about.\nstatic void checkUnusedDeclAttributes(Sema &S, const ParsedAttributesView &A) {\n for (const ParsedAttr &AL : A) {\n // ...\n if (AL.getKind() == ParsedAttr::UnknownAttribute) {\n // ...\n } else {\n S.Diag(AL.getLoc(), diag::warn_attribute_not_on_decl) << AL << AL.getRange();"}},
[l]={
["clang/test/SemaCXX/using-declspec.cpp"]={"clang/test/SemaCXX/using-declspec.cpp:5:27: warning: \'align\' attribute ignored when parsing type [-Wignored-attributes]","clang/test/SemaCXX/using-declspec.cpp:15:21: warning: \'align\' attribute ignored when parsing type [-Wignored-attributes]"}
}
},
["warn_attribute_on_function_definition"]={
[j]={kc},
[k]=kc,
[g]="warn_attribute_on_function_definition",
[b]="GCC does not allow %0 attribute in this position on a function definition",
[c]="GCC does not allow A attribute in this position on a function definition",
[d]=m,
[e]="GCC does not allow (.*?) attribute in this position on a function definition",
[f]=" \\[(?:\\-Werror,)?\\-Wgcc\\-compat[^\\]]*\\]",
[h]=db,
[a]={"3fc6e4a7cda9",1329411043,"Allow thread safety attributes on function definitions.","Allow thread safety attributes on function definitions.\nFor compatibility with gcc, clang will now parse gcc attributes on\nfunction definitions, but issue a warning if the attribute is not a\nthread safety attribute. Warning controlled by -Wgcc-compat.\n\nllvm-svn: 150698"},
[i]={{"clang/lib/Parse/ParseCXXInlineMethods.cpp",772,"/// Finish parsing an attribute for which parsing was delayed.\n/// This will be called at the end of parsing a class declaration\n/// for each LateParsedAttribute. We consume the saved tokens and\n/// create an attribute with the arguments filled in. We add this\n/// to the Attribute list for the decl.\nvoid Parser::ParseLexedAttribute(LateParsedAttribute &LA, bool EnterScope, bool OnDefinition) {\n // ...\n if (OnDefinition && !Attrs.empty() && !Attrs.begin()->isCXX11Attribute() && Attrs.begin()->isKnownToGCC())\n Diag(Tok, diag::warn_attribute_on_function_definition) << &LA.AttrName;"},{"clang/lib/Parse/Parser.cpp",1295,"/// ParseFunctionDefinition - We parsed and verified that the specified\n/// Declarator is well formed. If this is a K&R-style function, read the\n/// parameters declaration-list, then start the compound-statement.\n///\n/// function-definition: [C99 6.9.1]\n/// decl-specs declarator declaration-list[opt] compound-statement\n/// [C90] function-definition: [C99 6.7.1] - implicit int result\n/// [C90] decl-specs[opt] declarator declaration-list[opt] compound-statement\n/// [C++] function-definition: [C++ 8.4]\n/// decl-specifier-seq[opt] declarator ctor-initializer[opt]\n/// function-body\n/// [C++] function-definition: [C++ 8.4]\n/// decl-specifier-seq[opt] declarator function-try-block\n///\nDecl *Parser::ParseFunctionDefinition(ParsingDeclarator &D, const ParsedTemplateInfo &TemplateInfo, LateParsedAttrList *LateParsedAttrs) {\n // ...\n // Check to make sure that any normal attributes are allowed to be on\n // a definition. Late parsed attributes are checked at the end.\n if (Tok.isNot(tok::equal)) {\n for (const ParsedAttr &AL : D.getAttributes())\n if (AL.isKnownToGCC() && !AL.isStandardAttributeSyntax())\n Diag(AL.getLoc(), diag::warn_attribute_on_function_definition) << AL;"}},
[l]={
["clang/test/Parser/attributes.c"]={"clang/test/Parser/attributes.c:67:40: warning: GCC does not allow \'nonnull\' attribute in this position on a function definition [-Wgcc-compat]","clang/test/Parser/attributes.c:73:39: warning: GCC does not allow \'noreturn\' attribute in this position on a function definition [-Wgcc-compat]","clang/test/Parser/attributes.c:78:40: warning: GCC does not allow \'nonnull\' attribute in this position on a function definition [-Wgcc-compat]","clang/test/Parser/attributes.c:80:38: warning: GCC does not allow \'pure\' attribute in this position on a function definition [-Wgcc-compat]","clang/test/Parser/attributes.c:85:40: warning: GCC does not allow \'nonnull\' attribute in this position on a function definition [-Wgcc-compat]","clang/test/Parser/attributes.c:87:36: warning: GCC does not allow \'pure\' attribute in this position on a function definition [-Wgcc-compat]"}
}
},
["warn_attribute_packed_for_bitfield"]={
[j]={"attribute-packed-for-bitfield"},
[k]="attribute-packed-for-bitfield",
[g]="warn_attribute_packed_for_bitfield",
[b]="\'packed\' attribute was ignored on bit-fields with single-byte alignment in older versions of GCC and Clang",
[c]="\'packed\' attribute was ignored on bit-fields with single-byte alignment in older versions of GCC and Clang",
[d]=m,
[e]="\'packed\' attribute was ignored on bit\\-fields with single\\-byte alignment in older versions of GCC and Clang",
[f]=" \\[(?:\\-Werror,)?\\-Wattribute\\-packed\\-for\\-bitfield[^\\]]*\\]",
[h]=n,
[a]={"830dfccfb2c0",1449135289,"PR25575: Make GCC 4.4+ comatible layout for packed bit-fileds of char type, patch by D. Polukhin","PR25575: Make GCC 4.4+ comatible layout for packed bit-fileds of char type, patch by D. Polukhin\n\nThis CL is for discussion how to better fix bit-filed layout compatibility issue with GCC (see PR25575 for test case and more details). Current clang behavior is compatible with GCC 4.1-4.3 series but it was fixed in 4.4+. Ignoring packed attribute looks very odd and because it was also fixed in GCC 4.4+, it makes sense also fix it in clang.\nDifferential Revision: http://reviews.llvm.org/D14872\n\nllvm-svn: 254596"},
[i]={{o,1422,"static void handlePackedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (auto *TD = dyn_cast<TagDecl>(D))\n // ...\n else if (auto *FD = dyn_cast<FieldDecl>(D)) {\n // ...\n if (S.getASTContext().getTargetInfo().getTriple().isPS()) {\n // ...\n } else {\n // Report warning about changed offset in the newer compiler versions.\n if (BitfieldByteAligned)\n S.Diag(AL.getLoc(), diag::warn_attribute_packed_for_bitfield);"}},
[l]={
["clang/test/Sema/struct-packed-align.c"]={"clang/test/Sema/struct-packed-align.c:157:29: warning: \'packed\' attribute was ignored on bit-fields with single-byte alignment in older versions of GCC and Clang [-Wattribute-packed-for-bitfield]"}
}
},
["warn_attribute_pointer_or_reference_only"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_pointer_or_reference_only",
[b]="%0 attribute only applies to a pointer or reference (%1 is invalid)",
[c]="A attribute only applies to a pointer or reference (B is invalid)",
[d]=m,
[e]="(.*?) attribute only applies to a pointer or reference \\((.*?) is invalid\\)",
[f]=y,
[h]=n,
[a]={"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"},
[i]={{o,4323,"void Sema::AddAlignValueAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E) {\n // ...\n if (!T->isDependentType() && !T->isAnyPointerType() && !T->isReferenceType() && !T->isMemberPointerType()) {\n Diag(AttrLoc, diag::warn_attribute_pointer_or_reference_only) << &TmpAttr << T << D->getSourceRange();"}},
[l]={
["clang/test/Sema/align_value.c"]={"clang/test/Sema/align_value.c:26:28: warning: \'align_value\' attribute only applies to a pointer or reference (\'int\' is invalid) [-Wignored-attributes]"}
}
},
["warn_attribute_pointers_only"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_pointers_only",
[b]="%0 attribute only applies to%select{| constant}1 pointer arguments",
[c]={{nil,nil,{"A attribute only applies to",{r," constant"}," pointer arguments"}}},
[d]=m,
[e]="(.*?) attribute only applies to(?:| constant) pointer arguments",
[f]=y,
[h]=n,
[a]={"cedaaea69127",1388077669,"This diagnostic did not accept arguments, and did not have any test coverage. Parameterized the diag...","This diagnostic did not accept arguments, and did not have any test coverage. Parameterized the diagnostic, and made it more consistent with other attribute diagnostic wordings. Added test coverage.\n\nSince this warning was generalized, it was also given a sensible warning group flag and the corresponding test was updated to reflect this.\n\nllvm-svn: 198053"},
[i]={{o,1577,"static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL, SourceRange AttrParmRange, SourceRange TypeRange, bool isReturnValue = false) {\n if (!S.isValidPointerAttrType(T)) {\n if (isReturnValue)\n // ...\n else\n S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only) << AL << AttrParmRange << TypeRange << 0;"},{o,1664,"static void handleNoEscapeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!S.isValidPointerAttrType(T, /* RefOkay */ true)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_pointers_only) << AL << AL.getRange() << 0;"}},
[l]={
["clang/test/SemaObjC/nonnull.m"]={"clang/test/SemaObjC/nonnull.m:104:66: warning: \'nonnull\' attribute only applies to pointer arguments [-Wignored-attributes]"}
}
},
["warn_attribute_precede_definition"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_precede_definition",
[b]="attribute declaration must precede definition",
[c]="attribute declaration must precede definition",
[d]=m,
[e]="attribute declaration must precede definition",
[f]=y,
[h]=n,
[a]={"e5dc8594ea99",1248560984,"PR3575 - warn on declared variable or function attributes after a definition, which are currently ig...","PR3575 - warn on declared variable or function attributes after a definition, which are currently ignored.\n\nllvm-svn: 77095"},
[i]={{H,3122,"/// 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 S.Diag(NewAttribute->getLocation(), diag::warn_attribute_precede_definition);"}},
[l]={
["clang/test/Sema/attr-target-mv.c"]={"clang/test/Sema/attr-target-mv.c:60:20: warning: attribute declaration must precede definition [-Wignored-attributes]"}
}
},
["warn_attribute_protected_visibility"]={
[j]={"unsupported-visibility"},
[k]="unsupported-visibility",
[g]="warn_attribute_protected_visibility",
[b]="target does not support \'protected\' visibility; using \'default\'",
[c]="target does not support \'protected\' visibility; using \'default\'",
[d]=m,
[e]="target does not support \'protected\' visibility; using \'default\'",
[f]=" \\[(?:\\-Werror,)?\\-Wunsupported\\-visibility[^\\]]*\\]",
[h]=n,
[a]={"eed64c77d27f",1327800030,"Complain about attempts to use \'protected\' visibility on targets","Complain about attempts to use \'protected\' visibility on targets\nlike Darwin that don\'t support it. We should also complain about\ninvalid -fvisibility=protected, but that information doesn\'t seem\nto exist at the most appropriate time, so I\'ve left a FIXME behind.\n\nllvm-svn: 149186"},
[i]={{o,2926,"static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL, bool isTypeVisibility) {\n // ...\n // Complain about attempts to use protected visibility on targets\n // (like Darwin) that don\'t support it.\n if (type == VisibilityAttr::Protected && !S.Context.getTargetInfo().hasProtectedVisibility()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_protected_visibility);"}},
[l]={
["clang/test/Sema/attr-visibility.c"]={"clang/test/Sema/attr-visibility.c:8:33: warning: target does not support \'protected\' visibility; using \'default\' [-Wunsupported-visibility]"}
}
},
["warn_attribute_return_pointers_only"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_return_pointers_only",
[b]="%0 attribute only applies to return values that are pointers",
[c]="A attribute only applies to return values that are pointers",
[d]=m,
[e]="(.*?) attribute only applies to return values that are pointers",
[f]=y,
[h]=n,
[a]={"dbf62e3eee51",1390197047,"Wire up basic parser/sema support for attribute \'returns_nonnull\'.","Wire up basic parser/sema support for attribute \'returns_nonnull\'.\n\nThis attribute is supported by GCC. More generally it should\nprobably be a type attribute, but this behavior matches \'nonnull\'.\n\nThis patch does not include warning logic for checking if a null\nvalue is returned from a function annotated with this attribute.\nThat will come in subsequent patches.\n\nllvm-svn: 199626"},
[i]={{o,835,"static void handleAllocSizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!RetTy->isPointerType()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL;"},{o,1574,"static bool attrNonNullArgCheck(Sema &S, QualType T, const ParsedAttr &AL, SourceRange AttrParmRange, SourceRange TypeRange, bool isReturnValue = false) {\n if (!S.isValidPointerAttrType(T)) {\n if (isReturnValue)\n S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL << AttrParmRange << TypeRange;"},{o,2058,"static void handleRestrictAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n S.Diag(AL.getLoc(), diag::warn_attribute_return_pointers_only) << AL << getFunctionOrMethodResultSourceRange(D);"}},
[l]={
["clang/test/Sema/alloc-size.c"]={"clang/test/Sema/alloc-size.c:15:33: warning: \'alloc_size\' attribute only applies to return values that are pointers [-Wignored-attributes]"}
}
},
["warn_attribute_return_pointers_refs_only"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_return_pointers_refs_only",
[b]="%0 attribute only applies to return values that are pointers or references",
[c]="A attribute only applies to return values that are pointers or references",
[d]=m,
[e]="(.*?) attribute only applies to return values that are pointers or references",
[f]=y,
[h]=n,
[a]={"ee90a223ead9",1411707870,"Support the assume_aligned function attribute","Support the assume_aligned function attribute\n\nIn addition to __builtin_assume_aligned, GCC also supports an assume_aligned\nattribute which specifies the alignment (and optional offset) of a function\'s\nreturn value. Here we implement support for the assume_aligned attribute by making\nuse of the @llvm.assume intrinsic.\n\nllvm-svn: 218500"},
[i]={{o,1691,"void Sema::AddAssumeAlignedAttr(Decl *D, const AttributeCommonInfo &CI, Expr *E, Expr *OE) {\n // ...\n if (!isValidPointerAttrType(ResultType, /* RefOkay */ true)) {\n Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only) << &TmpAttr << TmpAttr.getRange() << SR;"},{o,1740,"void Sema::AddAllocAlignAttr(Decl *D, const AttributeCommonInfo &CI, Expr *ParamExpr) {\n // ...\n if (!ResultType->isDependentType() && !isValidPointerAttrType(ResultType, /* RefOkay */ true)) {\n Diag(AttrLoc, diag::warn_attribute_return_pointers_refs_only) << &TmpAttr << CI.getRange() << getFunctionOrMethodResultSourceRange(D);"}},
[l]={
["clang/test/Sema/alloc-align-attr.c"]={"clang/test/Sema/alloc-align-attr.c:4:49: warning: \'alloc_align\' attribute only applies to return values that are pointers or references [-Wignored-attributes]"}
}
},
["warn_attribute_section_drectve"]={
[j]={"microsoft","microsoft-drectve-section"},
[k]="microsoft-drectve-section",
[g]={{nil,B,"warn_attribute_section_drectve"}},
[b]={{nil,B,"#pragma %0(\".drectve\") has undefined behavior, use #pragma comment(linker, ...) instead"}},
[c]={{nil,B,"#pragma A(\".drectve\") has undefined behavior, use #pragma comment(linker, ...) instead"}},
[d]=m,
[e]="\\#pragma (.*?)\\(\"\\.drectve\"\\) has undefined behavior, use \\#pragma comment\\(linker, \\.\\.\\.\\) instead",
[f]=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-drectve\\-section[^\\]]*\\]",
[h]={{nil,B,n}},
[a]={"9801621616b2",1562630543,"clang-cl: Port cl.exe\'s C4659 to clang-cl","clang-cl: Port cl.exe\'s C4659 to clang-cl\n\nDifferential Revision: https://reviews.llvm.org/D64349\n\nllvm-svn: 365411"},
[i]={{"clang/lib/Sema/SemaAttr.cpp",756,"/// Called on well formed \\#pragma bss_seg().\nvoid Sema::ActOnPragmaMSSeg(SourceLocation PragmaLocation, PragmaMsStackAction Action, llvm::StringRef StackSlotLabel, StringLiteral *SegmentName, llvm::StringRef PragmaName) {\n // ...\n if (SegmentName) {\n // ...\n if (SegmentName->getString() == \".drectve\" && Context.getTargetInfo().getCXXABI().isMicrosoft())\n Diag(PragmaLocation, diag::warn_attribute_section_drectve) << PragmaName;"}},
[l]={
["clang/test/Sema/pragma-section.c"]={"clang/test/Sema/pragma-section.c:46:9: warning: #pragma bss_seg(\".drectve\") has undefined behavior, use #pragma comment(linker, ...) instead [-Wmicrosoft-drectve-section]","clang/test/Sema/pragma-section.c:47:9: warning: #pragma code_seg(\".drectve\") has undefined behavior, use #pragma comment(linker, ...) instead [-Wmicrosoft-drectve-section]","clang/test/Sema/pragma-section.c:48:9: warning: #pragma const_seg(\".drectve\") has undefined behavior, use #pragma comment(linker, ...) instead [-Wmicrosoft-drectve-section]","clang/test/Sema/pragma-section.c:49:9: warning: #pragma data_seg(\".drectve\") has undefined behavior, use #pragma comment(linker, ...) instead [-Wmicrosoft-drectve-section]"}
}
},
["warn_attribute_section_on_redeclaration"]={
[j]={"section"},
[k]="section",
[g]={{nil,N,"warn_attribute_section_on_redeclaration"}},
[b]={{nil,N,"section attribute is specified on redeclared variable"}},
[c]={{nil,N,"section attribute is specified on redeclared variable"}},
[d]=m,
[e]="section attribute is specified on redeclared variable",
[f]=" \\[(?:\\-Werror,)?\\-Wsection[^\\]]*\\]",
[h]={{nil,N,n}},
[a]={"99fdfb6a4644",1506469354,"Emit section information for extern variables. ","Emit section information for extern variables. \n\nCurrently, if _attribute_((section())) is used for extern variables, \nsection information is not emitted in generated IR when the variables are used. \nThis is expected since sections are not generated for external linkage objects. \nHowever NiosII requires this information as it uses special GP-relative accesses \nfor any objects that use attribute section (.sdata). GCC keeps this attribute in \n middle-end.\n\nThis change emits the section information for all targets.\n\nPatch By: Elizabeth Andrews\n\nDifferential Revision:https://reviews.llvm.org/D36487\n\nllvm-svn: 314262"},
[i]={{H,3272,"/// mergeDeclAttributes - Copy attributes from the Old decl to the New one.\nvoid Sema::mergeDeclAttributes(NamedDecl *New, Decl *Old, AvailabilityMergeKind AMK) {\n // ...\n // This redeclaration adds a section attribute.\n if (New->hasAttr<SectionAttr>() && !Old->hasAttr<SectionAttr>()) {\n if (auto *VD = dyn_cast<VarDecl>(New)) {\n if (VD->isThisDeclarationADefinition() == VarDecl::DeclarationOnly) {\n Diag(New->getLocation(), diag::warn_attribute_section_on_redeclaration);"}},
[l]={
["clang/test/SemaCXX/attr-section.cpp"]={"clang/test/SemaCXX/attr-section.cpp:21:12: warning: section attribute is specified on redeclared variable [-Wsection]"}
}
},
["warn_attribute_sentinel_named_arguments"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_sentinel_named_arguments",
[b]="\'sentinel\' attribute requires named arguments",
[c]="\'sentinel\' attribute requires named arguments",
[d]=m,
[e]="\'sentinel\' attribute requires named arguments",
[f]=y,
[h]=n,
[a]={"9363e3106edc",1237331027,"don\'t crash when sentinel attribute is used on function without a prototype,","don\'t crash when sentinel attribute is used on function without a prototype,\ndiscovered as part of PR3817\n\nllvm-svn: 67127"},
[i]={{o,3091,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n if (isa<FunctionNoProtoType>(FT)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_named_arguments);"}},
[l]={
["clang/test/Sema/sentinel-attribute.c"]={"clang/test/Sema/sentinel-attribute.c:19:26: warning: \'sentinel\' attribute requires named arguments [-Wignored-attributes]"}
}
},
["warn_attribute_sentinel_not_variadic"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_sentinel_not_variadic",
[b]="\'sentinel\' attribute only supported for variadic %select{functions|blocks}0",
[c]={{nil,nil,{"\'sentinel\' attribute only supported for variadic ",{Kb,"blocks"}}}},
[d]=m,
[e]="\'sentinel\' attribute only supported for variadic (?:functions|blocks)",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{o,3096,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n if (!cast<FunctionProtoType>(FT)->isVariadic()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;"},{o,3101,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n if (!MD->isVariadic()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 0;"},{o,3106,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n // ...\n } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {\n if (!BD->isVariadic()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << 1;"},{o,3119,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n // ...\n } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {\n // ...\n } else if (const auto *V = dyn_cast<VarDecl>(D)) {\n // ...\n if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {\n // ...\n if (!cast<FunctionProtoType>(FT)->isVariadic()) {\n // ...\n S.Diag(AL.getLoc(), diag::warn_attribute_sentinel_not_variadic) << m;"}},
[l]={
["clang/test/SemaObjC/method-sentinel-attr.m"]={"clang/test/SemaObjC/method-sentinel-attr.m:9:40: warning: \'sentinel\' attribute only supported for variadic functions [-Wignored-attributes]"}
}
},
["warn_attribute_type_not_supported"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_type_not_supported",
[b]="%0 attribute argument not supported: %1",
[c]="A attribute argument not supported: B",
[d]=m,
[e]="(.*?) attribute argument not supported\\: (.*?)",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{Tb,1574,"void Parser::ParseSwiftNewTypeAttribute(IdentifierInfo &AttrName, SourceLocation AttrNameLoc, ParsedAttributes &Attrs, SourceLocation *EndLoc, IdentifierInfo *ScopeName, SourceLocation ScopeLoc, ParsedAttr::Form Form) {\n // ...\n if (Tok.isNot(tok::kw_struct) && Tok.isNot(tok::kw_enum)) {\n Diag(Tok, diag::warn_attribute_type_not_supported) << &AttrName << Tok.getIdentifierInfo();"},{o,1212,"static void handleConsumableAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AL.isArgIdent(0)) {\n // ...\n if (!ConsumableAttr::ConvertStrToConsumedState(IL->Ident->getName(), DefaultState)) {\n S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;"},{o,1264,"static void handleCallableWhenAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n for (unsigned ArgIndex = 0; ArgIndex < AL.getNumArgs(); ++ArgIndex) {\n // ...\n if (!CallableWhenAttr::ConvertStrToConsumedState(StateString, CallableState)) {\n S.Diag(Loc, diag::warn_attribute_type_not_supported) << AL << StateString;"},{o,1284,"static void handleParamTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AL.isArgIdent(0)) {\n // ...\n if (!ParamTypestateAttr::ConvertStrToConsumedState(StateString, ParamState)) {\n S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL << StateString;"},{o,1316,"static void handleReturnTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AL.isArgIdent(0)) {\n // ...\n if (!ReturnTypestateAttr::ConvertStrToConsumedState(IL->Ident->getName(), ReturnState)) {\n S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;"},{o,1363,"static void handleSetTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AL.isArgIdent(0)) {\n // ...\n if (!SetTypestateAttr::ConvertStrToConsumedState(Param, NewState)) {\n S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL << Param;"},{o,1385,"static void handleTestTypestateAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AL.isArgIdent(0)) {\n // ...\n if (!TestTypestateAttr::ConvertStrToConsumedState(Param, TestState)) {\n S.Diag(Ident->Loc, diag::warn_attribute_type_not_supported) << AL << Param;"},{o,2917,"static void handleVisibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL, bool isTypeVisibility) {\n // ...\n if (!VisibilityAttr::ConvertStrToVisibilityType(TypeStr, type)) {\n S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL << TypeStr;"},{o,2975,"static void handleObjCMethodFamilyAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!ObjCMethodFamilyAttr::ConvertStrToFamilyKind(IL->Ident->getName(), F)) {\n S.Diag(IL->Loc, diag::warn_attribute_type_not_supported) << AL << IL->Ident;"},{o,3041,"static void handleBlocksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!BlocksAttr::ConvertStrToBlockType(II->getName(), type)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;"},{o,3763,"static void handleEnumExtensibilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!EnumExtensibilityAttr::ConvertStrToKind(II->getName(), ExtensibilityKind)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;"},{o,3962,"/// Handle __attribute__((format(type,idx,firstarg))) attributes based on\n/// http://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html\nstatic void handleFormatAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (Kind == InvalidFormat) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II->getName();"},{o,6427,"static void handleSwiftError(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!SwiftErrorAttr::ConvertStrToConventionKind(Loc->Ident->getName(), Convention)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Loc->Ident;"},{o,6543,"static void handleSwiftAsyncError(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!SwiftAsyncErrorAttr::ConvertStrToConventionKind(IDLoc->Ident->getName(), ConvKind)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << IDLoc->Ident;"},{o,6900,"static void handleSwiftNewType(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!SwiftNewTypeAttr::ConvertStrToNewtypeKind(II->getName(), Kind)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;"},{o,7192,"static void handleHLSLShaderAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!HLSLShaderAttr::ConvertStrToShaderType(Str, ShaderType) ||\n // ...\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str << ArgLoc;"},{o,7368,"static void handleARMInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!ARMInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str << ArgLoc;"},{o,7477,"static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!MipsInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << \"\'\" + std::string(Str) + \"\'\";"},{o,7798,"static void handleRISCVInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!RISCVInterruptAttr::ConvertStrToInterruptType(Str, Kind)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << Str << ArgLoc;"},{o,8344,"static void handleZeroCallUsedRegsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!ZeroCallUsedRegsAttr::ConvertStrToZeroCallUsedRegsKind(KindStr, Kind)) {\n S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL << KindStr;"},{o,8362,"static void handleFunctionReturnThunksAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!FunctionReturnThunksAttr::ConvertStrToKind(KindStr, Kind)) {\n S.Diag(LiteralLoc, diag::warn_attribute_type_not_supported) << AL << KindStr;"},{o,8600,"static void handleCFGuardAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!CFGuardAttr::ConvertStrToGuardArg(II->getName(), Arg)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_type_not_supported) << AL << II;"},{lb,6953,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n // ...\n if (II->isStr(\"none\"))\n // ...\n else if (II->isStr(\"strong\"))\n // ...\n else if (II->isStr(\"weak\"))\n // ...\n else if (II->isStr(\"autoreleasing\"))\n // ...\n else {\n S.Diag(AttrLoc, diag::warn_attribute_type_not_supported) << attr << II;"},{lb,7126,"/// handleObjCGCTypeAttr - Process the __attribute__((objc_gc)) type\n/// attribute on the specified type. Returns true to indicate that\n/// the attribute was handled, false to indicate that the type does\n/// not permit the attribute.\nstatic bool handleObjCGCTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n // ...\n if (II->isStr(\"weak\"))\n // ...\n else if (II->isStr(\"strong\"))\n // ...\n else {\n S.Diag(attr.getLoc(), diag::warn_attribute_type_not_supported) << attr << II;"}},
[l]={
["clang/test/SemaCXX/warn-consumed-parsing.cpp"]={"clang/test/SemaCXX/warn-consumed-parsing.cpp:39:39: warning: \'callable_when\' attribute argument not supported: foo [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:45:55: warning: \'return_typestate\' attribute argument not supported: \'not_a_state\' [-Wignored-attributes]"}
}
},
["warn_attribute_type_not_supported_global"]={
[j]={x,q},
[k]=q,
[g]={{nil,v,"warn_attribute_type_not_supported_global"}},
[b]={{nil,v,"%0 attribute argument \'%1\' not supported on a global variable"}},
[c]={{nil,v,"A attribute argument \'B\' not supported on a global variable"}},
[d]=m,
[e]="(.*?) attribute argument \'(.*?)\' not supported on a global variable",
[f]=y,
[h]={{nil,v,n}},
[a]={sb,1625925174,rb,vb},
[i]={{o,8234,"static void handleNoSanitizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n for (unsigned I = 0, E = AL.getNumArgs(); I != E; ++I) {\n // ...\n if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == SanitizerMask() && SanitizerName != \"coverage\")\n // ...\n else if (isGlobalVar(D) && !isSanitizerAttributeAllowedOnGlobals(SanitizerName))\n S.Diag(D->getLocation(), diag::warn_attribute_type_not_supported_global) << AL << SanitizerName;"}},
[l]={
["clang/test/SemaCXX/attr-no-sanitize.cpp"]={"clang/test/SemaCXX/attr-no-sanitize.cpp:9:41: warning: \'no_sanitize\' attribute argument \'all\' not supported on a global variable [-Wignored-attributes]"}
}
},
["warn_attribute_unknown_visibility"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_unknown_visibility",
[b]="unknown visibility %0",
[c]="unknown visibility A",
[d]=m,
[e]="unknown visibility (.*?)",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{"clang/lib/Sema/SemaAttr.cpp",1304,"void Sema::ActOnPragmaVisibility(const IdentifierInfo *VisType, SourceLocation PragmaLoc) {\n if (VisType) {\n // ...\n if (!VisibilityAttr::ConvertStrToVisibilityType(VisType->getName(), T)) {\n Diag(PragmaLoc, diag::warn_attribute_unknown_visibility) << VisType;"}}
},
["warn_attribute_void_function_method"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_void_function_method",
[b]="attribute %0 cannot be applied to %select{functions|Objective-C method}1 without return value",
[c]={{nil,nil,{"attribute A cannot be applied to ",{Kb,"Objective-C method"}," without return value"}}},
[d]=m,
[e]="attribute (.*?) cannot be applied to (?:functions|Objective\\-C method) without return value",
[f]=y,
[h]=n,
[a]={"5cab26d058d3",1269973335,"Add Support for \'warn_unused_result\" attribute on","Add Support for \'warn_unused_result\" attribute on\nobjective-c methods. (radar 7418262).\n\nllvm-svn: 99903"},
[i]={{o,3141,"static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (D->getFunctionType() && D->getFunctionType()->getReturnType()->isVoidType() && !isa<CXXConstructorDecl>(D)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 0;"},{o,3146,"static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *MD = dyn_cast<ObjCMethodDecl>(D))\n if (MD->getReturnType()->isVoidType()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_void_function_method) << AL << 1;"}},
[l]={
["clang/test/Sema/unused-expr.c"]={"clang/test/Sema/unused-expr.c:107:30: warning: attribute \'warn_unused_result\' cannot be applied to functions without return value [-Wignored-attributes]"}
}
},
["warn_attribute_weak_on_field"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_weak_on_field",
[b]="__weak attribute cannot be specified on a field declaration",
[c]="__weak attribute cannot be specified on a field declaration",
[d]=m,
[e]="__weak attribute cannot be specified on a field declaration",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{H,18265,"/// 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 (T.isObjCGCWeak())\n Diag(Loc, diag::warn_attribute_weak_on_field);"}},
[l]={
["clang/test/SemaObjC/objc2-warn-weak-decl.m"]={"clang/test/SemaObjC/objc2-warn-weak-decl.m:4:13: warning: __weak attribute cannot be specified on a field declaration [-Wignored-attributes]"}
}
},
["warn_attribute_weak_on_local"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_weak_on_local",
[b]="__weak attribute cannot be specified on an automatic variable when ARC is not enabled",
[c]="__weak attribute cannot be specified on an automatic variable when ARC is not enabled",
[d]=m,
[e]="__weak attribute cannot be specified on an automatic variable when ARC is not enabled",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{H,8651,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n // ...\n if (NewVD->hasLocalStorage() && T.isObjCGCWeak() && !NewVD->hasAttr<BlocksAttr>()) {\n if (getLangOpts().getGC() != LangOptions::NonGC)\n // ...\n else {\n // ...\n Diag(NewVD->getLocation(), diag::warn_attribute_weak_on_local);"}}
},
["warn_attribute_wrong_decl_type"]={
[j]={x,q},
[k]=q,
[g]="warn_attribute_wrong_decl_type",
[b]="%0%select{ attribute|}1 only applies to %select{functions|unions|variables and functions|functions and methods|functions, methods and blocks|functions, methods, and parameters|variables|variables and fields|variables, data members and tag types|types and namespaces|variables, functions and classes|kernel functions|non-K&R-style functions}2",
[c]={{nil,nil,{Sb,{" attribute",r}," only applies to ",{Kb,Ec,Fc,qc,Gc,Hc,Bc,xc,wc,vc,uc,Ic,rc}}},{v,F,{"A attribute only applies to ",{Kb,Ec,Fc,qc,Gc,Hc,Bc,xc,wc,vc,uc,Ic,rc}}},{N,N,{"A attribute only applies to ",{Kb,Ec,Fc,qc,Gc,Hc,Bc,xc,wc,vc,uc,Ic,rc,"variables, functions, methods, types, enumerations, enumerators, labels, and non-static data members"}}},{E,E,{"A attribute only applies to ",{Kb,Ec,Fc,"functions and global variables","functions, variables, and Objective-C interfaces",qc,"parameters",Gc,"functions, methods, and classes",Hc,"functions, methods, and global variables","classes","enums",Bc,"methods","fields and global variables","structs","parameters and typedefs","variables and typedefs","thread-local variables",xc,wc,vc,"Objective-C interfaces","methods and properties","functions, methods, and properties","struct or union","struct, union or class","types","Objective-C instance methods","init methods of interface or class extension declarations",uc,"functions, variables, classes, and Objective-C interfaces","Objective-C protocols","variables with static or thread storage duration","functions, methods, properties, and global variables","structs, unions, and typedefs","structs and typedefs","interface or protocol declarations",Ic,rc,"variables, enums, fields and typedefs","functions, methods, enums, and classes","structs, classes, variables, functions, and inline namespaces","variables, functions, methods, types, enumerations, enumerators, labels, and non-static data members","classes and enumerations","named declarations"}}},{nil,nil,{"A attribute only applies to ",{Kb,Ec,Fc,"functions and global variables","functions, variables, and Objective-C interfaces",qc,"parameters",Gc,"functions, methods, and classes",Hc,"functions, methods, and global variables","classes","enums",Bc,"methods","fields and global variables","structs","parameters and typedefs","variables and typedefs","thread-local variables",xc,wc,vc,"Objective-C interfaces","methods and properties","struct or union","struct, union or class","types","Objective-C instance methods","init methods of interface or class extension declarations",uc,"functions, variables, classes, and Objective-C interfaces","Objective-C protocols","variables with static or thread storage duration","functions, methods, properties, and global variables","structs, unions, and typedefs","structs and typedefs","interface or protocol declarations",Ic,rc,"variables, enums, fields and typedefs","functions, methods, enums, and classes","structs, classes, variables, functions, and inline namespaces","variables, functions, methods, types, enumerations, enumerators, labels, and non-static data members","classes and enumerations"}}}},
[d]=m,
[e]="(.*?)(?: attribute|) only applies to (?:functions|unions|variables and functions|functions and methods|functions, methods and blocks|functions, methods, and parameters|variables|variables and fields|variables, data members and tag types|types and namespaces|variables, functions and classes|kernel functions|non\\-K&R\\-style functions)",
[f]=y,
[h]=n,
[a]={K,1236199783,J,I},
[i]={{"clang/lib/Sema/Sema.cpp",1186,"/// ActOnEndOfTranslationUnit - This is called at the very end of the\n/// translation unit when EOF is reached and all but the top-level scope is\n/// popped.\nvoid Sema::ActOnEndOfTranslationUnit() {\n // ...\n for (const auto &WeakIDs : WeakUndeclaredIdentifiers) {\n // ...\n if (PrevDecl != nullptr && !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))\n for (const auto &WI : WeakIDs.second)\n Diag(WI.getLocation(), diag::warn_attribute_wrong_decl_type) << \"\'weak\'\" << /*isRegularKeyword=*/0 << ExpectedVariableOrFunction;"},{o,2186,"static void handleNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &Attrs) {\n // ...\n if (!isa<ObjCMethodDecl>(D)) {\n S.Diag(Attrs.getLoc(), diag::warn_attribute_wrong_decl_type) << Attrs << Attrs.isRegularKeywordAttribute() << ExpectedFunctionOrMethod;"},{o,2250,"static void handleAnalyzerNoReturnAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // The checking path for \'noreturn\' and \'analyzer_noreturn\' are different\n // because \'analyzer_noreturn\' does not impact the type.\n if (!isFunctionOrMethodOrBlock(D)) {\n // ...\n if (!VD || (!VD->getType()->isBlockPointerType() && !VD->getType()->isFunctionPointerType())) {\n S.Diag(AL.getLoc(), AL.isStandardAttributeSyntax() ? diag::err_attribute_wrong_decl_type : diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionMethodOrBlock;"},{o,3123,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n // ...\n } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {\n // ...\n } else if (const auto *V = dyn_cast<VarDecl>(D)) {\n // ...\n if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) {\n // ...\n } else {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionMethodOrBlock;"},{o,3129,"static void handleSentinelAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n // ...\n } else if (const auto *BD = dyn_cast<BlockDecl>(D)) {\n // ...\n } else if (const auto *V = dyn_cast<VarDecl>(D)) {\n // ...\n } else {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionMethodOrBlock;"},{o,3202,"static void handleWeakImportAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!D->canBeWeakImported(isDef)) {\n if (isDef)\n // ...\n else if (isa<ObjCPropertyDecl>(D) || isa<ObjCMethodDecl>(D) || (S.Context.getTargetInfo().getTriple().isOSDarwin() && (isa<ObjCInterfaceDecl>(D) || isa<EnumDecl>(D)))) {\n // ...\n } else\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedVariableOrFunction;"},{o,4218,"static void handleTransparentUnionAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!RD || !RD->isUnion()) {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedUnion;"},{o,4904,"InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D, const ParsedAttr &AL) {\n if (const auto *VD = dyn_cast<VarDecl>(D)) {\n // Attribute applies to Var but not any subclass of it (like ParmVar,\n // ImplicitParm or VarTemplateSpecialization).\n if (VD->getKind() != Decl::Var) {\n Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : ExpectedVariableOrFunction);"},{o,4925,"InternalLinkageAttr *Sema::mergeInternalLinkageAttr(Decl *D, const InternalLinkageAttr &AL) {\n if (const auto *VD = dyn_cast<VarDecl>(D)) {\n // Attribute applies to Var but not any subclass of it (like ParmVar,\n // ImplicitParm or VarTemplateSpecialization).\n if (VD->getKind() != Decl::Var) {\n Diag(AL.getLocation(), diag::warn_attribute_wrong_decl_type) << &AL << AL.isRegularKeywordAttribute() << (getLangOpts().CPlusPlus ? ExpectedFunctionVariableOrClass : ExpectedVariableOrFunction);"},{o,5125,"static void handleCallConvAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!isa<ObjCMethodDecl>(D)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionOrMethod;"},{o,6012,"static void handleXReturnsXRetainedAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (const auto *MD = dyn_cast<ObjCMethodDecl>(D)) {\n // ...\n } else if (S.getLangOpts().ObjCAutoRefCount && hasDeclarator(D) && (AL.getKind() == ParsedAttr::AT_NSReturnsRetained)) {\n // ...\n } else if (const auto *PD = dyn_cast<ObjCPropertyDecl>(D)) {\n // ...\n } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {\n // ...\n } else if (const auto *Param = dyn_cast<ParmVarDecl>(D)) {\n // ...\n } else if (AL.isUsedAsTypeAttr()) {\n // ...\n } else {\n // ...\n S.Diag(D->getBeginLoc(), diag::warn_attribute_wrong_decl_type) << AL.getRange() << AL << AL.isRegularKeywordAttribute() << ExpectedDeclKind;"},{o,6784,"bool Sema::DiagnoseSwiftName(Decl *D, StringRef Name, SourceLocation Loc, const ParsedAttr &AL, bool IsAsync) {\n if (isa<ObjCMethodDecl>(D) || isa<FunctionDecl>(D)) {\n // ...\n if (const auto *Method = dyn_cast<ObjCMethodDecl>(D)) {\n // ...\n } else {\n // ...\n if (!F->hasWrittenPrototype()) {\n Diag(Loc, diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionWithProtoType;"},{o,7380,"static void handleMSP430InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // MSP430 \'interrupt\' attribute is applied to\n // a function with no parameters and void return type.\n if (!isFunctionOrMethod(D)) {\n S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionOrMethod;"},{o,7453,"static void handleMipsInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!isFunctionOrMethod(D)) {\n S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionOrMethod;"},{o,7528,"static void handleAnyX86InterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // Semantic checks for a function with the \'interrupt\' attribute.\n // a) Must be a function.\n // b) Must have the \'void\' return type.\n // c) Must take 1 or 2 arguments.\n // d) The 1st argument must be a pointer.\n // e) The 2nd argument (if any) must be an unsigned integer.\n if (!isFunctionOrMethod(D) || !hasFunctionProto(D) || isInstanceMethod(D) || CXXMethodDecl::isStaticOverloadedOperator(cast<NamedDecl>(D)->getDeclName().getCXXOverloadedOperator())) {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunctionWithProtoType;"},{o,7585,"static void handleAVRInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (!isFunctionOrMethod(D)) {\n S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunction;"},{o,7598,"static void handleAVRSignalAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (!isFunctionOrMethod(D)) {\n S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunction;"},{o,7655,"static void handleWebAssemblyExportNameAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n if (!isFunctionOrMethod(D)) {\n S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunction;"},{o,7779,"static void handleRISCVInterruptAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (D->getFunctionType() == nullptr) {\n S.Diag(D->getLocation(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunction;"},{o,7974,"static void handleX86ForceAlignArgPointerAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n // Attribute can only be applied to function types.\n if (!isa<FunctionDecl>(D)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type) << AL << AL.isRegularKeywordAttribute() << ExpectedFunction;"}},
[l]={
["clang/test/SemaCXX/warn-consumed-parsing.cpp"]={"clang/test/SemaCXX/warn-consumed-parsing.cpp:25:10: warning: \'set_typestate\' attribute only applies to functions [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:26:10: warning: \'test_typestate\' attribute only applies to functions [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:27:10: warning: \'callable_when\' attribute only applies to functions [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:31:18: warning: \'set_typestate\' attribute only applies to functions [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:32:18: warning: \'test_typestate\' attribute only applies to functions [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:33:18: warning: \'callable_when\' attribute only applies to functions [-Wignored-attributes]"}
}
},
["warn_attribute_wrong_decl_type_str"]={
[j]={x,q},
[k]=q,
[g]={{nil,N,"warn_attribute_wrong_decl_type_str"}},
[b]="%0%select{ attribute|}1 only applies to %2",
[c]={{nil,nil,{Sb,{" attribute",r}," only applies to C"}},{v,N,"A attribute only applies to B"}},
[d]=m,
[e]="(.*?)(?: attribute|) only applies to (.*?)",
[f]=y,
[h]={{nil,N,n}},
[a]={"adf66b617461",1511726472,"Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. Th...","Determine the attribute subject for diagnostics based on declarative information in DeclNodes.td. This greatly reduces the number of enumerated values used for more complex diagnostics; these are now only required when the \"attribute only applies to\" diagnostic needs to be generated manually as part of semantic processing.\n\nThis also clarifies some terminology used by the diagnostic (methods -> Objective-C methods, fields -> non-static data members, etc).\n\nMany of the tests needed to be updated in multiple places for the diagnostic wording tweaks. The first instance of the diagnostic for that attribute is fully specified and subsequent instances cut off the complete list (to make it easier if additional subjects are added in the future for the attribute).\n\nllvm-svn: 319002"},
[i]={{"clang/examples/Attribute/Attribute.cpp",46,"struct ExampleAttrInfo : public ParsedAttrInfo {\n // ...\n bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {\n // This attribute appertains to functions only.\n if (!isa<FunctionDecl>(D)) {\n S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << \"functions\";"},{"clang/examples/CallSuperAttribute/CallSuperAttrInfo.cpp",172,"struct CallSuperAttrInfo : public ParsedAttrInfo {\n // ...\n bool diagAppertainsToDecl(Sema &S, const ParsedAttr &Attr, const Decl *D) const override {\n // ...\n if (!TheMethod || !TheMethod->isVirtual()) {\n S.Diag(Attr.getLoc(), diag::warn_attribute_wrong_decl_type_str) << Attr << Attr.isRegularKeywordAttribute() << \"virtual functions\";"},{o,3155,"static void handleWarnUnusedResult(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AL.isStandardAttributeSyntax() && !AL.getScopeName()) {\n // The standard attribute cannot be applied to variable declarations such\n // as a function pointer.\n if (isa<VarDecl>(D))\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str) << AL << AL.isRegularKeywordAttribute() << \"functions, classes, or enumerations\";"},{o,6905,"static void handleSwiftNewType(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (!isa<TypedefNameDecl>(D)) {\n S.Diag(AL.getLoc(), diag::warn_attribute_wrong_decl_type_str) << AL << AL.isRegularKeywordAttribute() << \"typedefs\";"}},
[l]={
["clang/test/SemaCXX/warn-consumed-parsing.cpp"]={"clang/test/SemaCXX/warn-consumed-parsing.cpp:28:10: warning: \'consumable\' attribute only applies to classes [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:29:10: warning: \'return_typestate\' attribute only applies to functions and parameters [-Wignored-attributes]","clang/test/SemaCXX/warn-consumed-parsing.cpp:34:18: warning: \'consumable\' attribute only applies to classes [-Wignored-attributes]"}
}
},
["warn_attributes_likelihood_ifstmt_conflict"]={
[j]={x,q},
[k]=q,
[g]={{nil,p,"warn_attributes_likelihood_ifstmt_conflict"}},
[b]={{nil,p,"conflicting attributes %0 are ignored"}},
[c]={{nil,p,"conflicting attributes A are ignored"}},
[d]=m,
[e]="conflicting attributes (.*?) are ignored",
[f]=y,
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{X,929,"StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *thenStmt, SourceLocation ElseLoc, Stmt *elseStmt) {\n // ...\n if (ConstevalOrNegatedConsteval || StatementKind == IfStatementKind::Constexpr) {\n // ...\n } else {\n // ...\n if (std::get<0>(LHC)) {\n // ...\n Diags.Report(ThenAttr->getLocation(), diag::warn_attributes_likelihood_ifstmt_conflict) << ThenAttr << ThenAttr->getRange();"}},
[l]={
["clang/test/SemaCXX/attr-likelihood.cpp"]={"clang/test/SemaCXX/attr-likelihood.cpp:14:7: warning: conflicting attributes \'likely\' are ignored [-Wignored-attributes]","clang/test/SemaCXX/attr-likelihood.cpp:21:7: warning: conflicting attributes \'unlikely\' are ignored [-Wignored-attributes]"}
}
},
["warn_auto_implicit_atomic_property"]={
[j]={"atomic-properties","implicit-atomic-properties"},
[k]="implicit-atomic-properties",
[g]="warn_auto_implicit_atomic_property",
[b]="property is assumed atomic when auto-synthesizing the property",
[c]="property is assumed atomic when auto-synthesizing the property",
[d]=m,
[e]="property is assumed atomic when auto\\-synthesizing the property",
[f]=" \\[(?:\\-Werror,)?\\-Wimplicit\\-atomic\\-properties[^\\]]*\\]",
[h]=n,
[a]={"382c040da2a6",1292624896,"Warn when synthesizing a property which is","Warn when synthesizing a property which is\nimplicitly atomic under -Wimplicit-atomic-properties\nflag. // rdar://8774580\n\nllvm-svn: 122095"},
[i]={{pb,1127,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n // ...\n if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {\n // ...\n if ((PIkind & (ObjCPropertyAttribute::kind_atomic | ObjCPropertyAttribute::kind_nonatomic)) == 0) {\n if (AtLoc.isValid())\n // ...\n else\n Diag(IC->getLocation(), diag::warn_auto_implicit_atomic_property);"}},
[l]={
["clang/test/SemaObjC/warn-implicit-atomic-property.m"]={"clang/test/SemaObjC/warn-implicit-atomic-property.m:11:17: warning: property is assumed atomic when auto-synthesizing the property [-Wimplicit-atomic-properties]"}
}
},
["warn_auto_readonly_iboutlet_property"]={
[j]={"readonly-iboutlet-property"},
[k]="readonly-iboutlet-property",
[g]="warn_auto_readonly_iboutlet_property",
[b]="readonly IBOutlet property %0 when auto-synthesized may not work correctly with \'nib\' loader",
[c]="readonly IBOutlet property A when auto-synthesized may not work correctly with \'nib\' loader",
[d]=m,
[e]="readonly IBOutlet property (.*?) when auto\\-synthesized may not work correctly with \'nib\' loader",
[f]=" \\[(?:\\-Werror,)?\\-Wreadonly\\-iboutlet\\-property[^\\]]*\\]",
[h]=n,
[a]={"199a9b57a6bb",1337451437,"objective-c: Warn if default synthesizing readonly IBOutlet properties","objective-c: Warn if default synthesizing readonly IBOutlet properties\nand provide a \'fixit\' to change \'readonly\' to \'readwrite\'. \'fixit\'\npart needs little more work. // rdar://11448209\n\nllvm-svn: 157121"},
[i]={{pb,1156,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n // ...\n if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {\n // ...\n if (Synthesize && (PIkind & ObjCPropertyAttribute::kind_readonly) && property->hasAttr<IBOutletAttr>() && !AtLoc.isValid()) {\n // ...\n if (!ReadWriteProperty) {\n Diag(property->getLocation(), diag::warn_auto_readonly_iboutlet_property) << property;"}},
[l]={
["clang/test/SemaObjC/iboutlet.m"]={"clang/test/SemaObjC/iboutlet.m:10:66: warning: readonly IBOutlet property \'myView\' when auto-synthesized may not work correctly with \'nib\' loader [-Wreadonly-iboutlet-property]","clang/test/SemaObjC/iboutlet.m:12:53: warning: readonly IBOutlet property \'myView1\' when auto-synthesized may not work correctly with \'nib\' loader [-Wreadonly-iboutlet-property]","clang/test/SemaObjC/iboutlet.m:14:59: warning: readonly IBOutlet property \'myView2\' when auto-synthesized may not work correctly with \'nib\' loader [-Wreadonly-iboutlet-property]","clang/test/SemaObjC/iboutlet.m:28:58: warning: readonly IBOutlet property \'autoReadOnlyReadOnly\' when auto-synthesized may not work correctly with \'nib\' loader [-Wreadonly-iboutlet-property]"}
}
},
["warn_auto_storage_class"]={
[j]={"c++0x-compat","c++11-compat","c++11-compat-pedantic"},
[k]="c++11-compat",
[g]="warn_auto_storage_class",
[b]="\'auto\' storage class specifier is redundant and incompatible with C++11",
[c]="\'auto\' storage class specifier is redundant and incompatible with C++11",
[d]=m,
[e]="\'auto\' storage class specifier is redundant and incompatible with C\\+\\+11",
[f]=" \\[(?:\\-Werror,)?\\-Wc\\+\\+11\\-compat[^\\]]*\\]",
[h]=n,
[a]={"58c743370994",1315166054,"PR10458: Finesse behaviour of C++0x features when in pre-0x mode. Accept for-range and auto with an ...","PR10458: Finesse behaviour of C++0x features when in pre-0x mode. Accept for-range and auto with an ExtWarn, and produce a -Wc++0x-compat warning in C++98 mode when auto is used as a storage class.\n\nllvm-svn: 139102"},
[i]={{"clang/lib/Sema/DeclSpec.cpp",1372,"/// Finish - This does final analysis of the declspec, rejecting things like\n/// \"_Imaginary\" (lacking an FP type). After calling this method, DeclSpec is\n/// guaranteed to be self-consistent, even if an error occurred.\nvoid DeclSpec::Finish(Sema &S, const PrintingPolicy &Policy) {\n // ...\n if (S.getLangOpts().CPlusPlus && !S.getLangOpts().CPlusPlus11 && StorageClassSpec == SCS_auto)\n S.Diag(StorageClassSpecLoc, diag::warn_auto_storage_class) << FixItHint::CreateRemoval(StorageClassSpecLoc);"}},
[l]={
["clang/test/SemaCXX/auto-cxx98.cpp"]={"clang/test/SemaCXX/auto-cxx98.cpp:3:3: warning: \'auto\' storage class specifier is redundant and incompatible with C++11 [-Wc++11-compat]","clang/test/SemaCXX/auto-cxx98.cpp:4:7: warning: \'auto\' storage class specifier is redundant and incompatible with C++11 [-Wc++11-compat]"}
}
},
["warn_auto_synthesizing_protocol_property"]={
[j]={"objc-protocol-property-synthesis"},
[k]="objc-protocol-property-synthesis",
[g]="warn_auto_synthesizing_protocol_property",
[b]="auto property synthesis will not synthesize property %0 declared in protocol %1",
[c]="auto property synthesis will not synthesize property A declared in protocol B",
[d]=m,
[e]="auto property synthesis will not synthesize property (.*?) declared in protocol (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-protocol\\-property\\-synthesis[^\\]]*\\]",
[h]=n,
[a]={"9e49b6a6ffae",1323910998,"objc: do not auto synthesize properties declared in","objc: do not auto synthesize properties declared in\nprotocols; with a warning. // rdar://10567333\n\nllvm-svn: 146626"},
[i]={{pb,1935,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n // ...\n for (const auto &PropEntry : PropMap) {\n // ...\n if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(Prop->getDeclContext())) {\n // We won\'t auto-synthesize properties declared in protocols.\n // Suppress the warning if class\'s superclass implements property\'s\n // getter and implements property\'s setter (if readwrite property).\n // Or, if property is going to be implemented in its super class.\n if (!SuperClassImplementsProperty(IDecl, Prop) && !PropInSuperClass) {\n Diag(IMPDecl->getLocation(), diag::warn_auto_synthesizing_protocol_property) << Prop << Proto;"}},
[l]={
["clang/test/SemaObjC/default-synthesize.m"]={"clang/test/SemaObjC/default-synthesize.m:139:17: warning: auto property synthesis will not synthesize property \'requiredString\' declared in protocol \'MyProtocol\' [-Wobjc-protocol-property-synthesis]"}
}
},
["warn_auto_var_is_id"]={
[j]={"auto-var-id"},
[k]="auto-var-id",
[g]="warn_auto_var_is_id",
[b]="\'auto\' deduced as \'id\' in declaration of %0",
[c]="\'auto\' deduced as \'id\' in declaration of A",
[d]=m,
[e]="\'auto\' deduced as \'id\' in declaration of (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wauto\\-var\\-id[^\\]]*\\]",
[h]=n,
[a]={"d8d56694352c",1339195567,"Warn in ObjC++ when an \'auto\' variable deduces type \'id\'.","Warn in ObjC++ when an \'auto\' variable deduces type \'id\'.\n\nThis could happen for cases like this:\n\n- (NSArray *)getAllNames:(NSArray *)images {\n NSMutableArray *results = [NSMutableArray array];\n for (auto img in images) {\n [results addObject:img.name];\n }\n return results;\n}\n\nHere the property access will fail because \'img\' has type \'id\', rather than,\nsay, NSImage.\n\nThis warning will not fire in templated code, since the \'id\' could have\ncome from a template parameter.\n\nllvm-svn: 158239"},
[i]={{H,12805,"QualType Sema::deduceVarTypeFromInitializer(VarDecl *VDecl, DeclarationName Name, QualType Type, TypeSourceInfo *TSI, SourceRange Range, bool DirectInit, Expr *Init) {\n // ...\n // Warn if we deduced \'id\'. \'auto\' usually implies type-safety, but using\n // \'id\' instead of a specific object type prevents most of our usual\n // checks.\n // We only want to warn outside of template instantiations, though:\n // inside a template, the \'id\' could have come from a parameter.\n if (!inTemplateInstantiation() && !DefaultedAnyToId && !IsInitCapture && !DeducedType.isNull() && DeducedType->isObjCIdType()) {\n // ...\n Diag(Loc, diag::warn_auto_var_is_id) << VN << Range;"},{X,2331,"StmtResult Sema::ActOnObjCForCollectionStmt(SourceLocation ForLoc, Stmt *First, Expr *collection, SourceLocation RParenLoc) {\n // ...\n if (First) {\n // ...\n if (DeclStmt *DS = dyn_cast<DeclStmt>(First)) {\n // ...\n // If the type contained \'auto\', deduce the \'auto\' to \'id\'.\n if (FirstType->getContainedAutoType()) {\n // ...\n if (!inTemplateInstantiation()) {\n // ...\n Diag(Loc, diag::warn_auto_var_is_id) << D->getDeclName();"}},
[l]={
["clang/test/SemaObjCXX/foreach.mm"]={"clang/test/SemaObjCXX/foreach.mm:14:8: warning: \'auto\' deduced as \'id\' in declaration of \'thisKey\' [-Wauto-var-id]"}
}
},
["warn_autosynthesis_property_in_superclass"]={
[j]={"objc-property-synthesis"},
[k]="objc-property-synthesis",
[g]="warn_autosynthesis_property_in_superclass",
[b]="auto property synthesis will not synthesize property %0; it will be implemented by its superclass, use @dynamic to acknowledge intention",
[c]="auto property synthesis will not synthesize property A; it will be implemented by its superclass, use @dynamic to acknowledge intention",
[d]=m,
[e]="auto property synthesis will not synthesize property (.*?); it will be implemented by its superclass, use @dynamic to acknowledge intention",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-property\\-synthesis[^\\]]*\\]",
[h]=n,
[a]={"6c9ee7b0c856",1406407946,"Objective-C. Issue more warning diagnostic when certain","Objective-C. Issue more warning diagnostic when certain\nproperties are not synthesized in property auto-synthesis,\nas it can potentiall lead to runtime errors.\nrdar://17774815\n\nllvm-svn: 214032"},
[i]={{pb,1957,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n // ...\n for (const auto &PropEntry : PropMap) {\n // ...\n // If property to be implemented in the super class, ignore.\n if (PropInSuperClass) {\n if ((Prop->getPropertyAttributes() & ObjCPropertyAttribute::kind_readwrite) && (PropInSuperClass->getPropertyAttributes() & ObjCPropertyAttribute::kind_readonly) && !IMPDecl->getInstanceMethod(Prop->getSetterName()) && !IDecl->HasUserDeclaredSetterMethod(Prop)) {\n // ...\n } else {\n Diag(Prop->getLocation(), diag::warn_autosynthesis_property_in_superclass) << Prop->getIdentifier();"}},
[l]={
["clang/test/SemaObjC/super-property-notation.m"]={"clang/test/SemaObjC/super-property-notation.m:44:46: warning: auto property synthesis will not synthesize property \'foo\'; it will be implemented by its superclass, use @dynamic to acknowledge intention [-Wobjc-property-synthesis]"}
}
},
["warn_autosynthesis_property_ivar_match"]={
[j]={"objc-autosynthesis-property-ivar-name-match"},
[k]="objc-autosynthesis-property-ivar-name-match",
[g]="warn_autosynthesis_property_ivar_match",
[b]="autosynthesized property %0 will use %select{|synthesized}1 instance variable %2, not existing instance variable %3",
[c]={{nil,nil,{"autosynthesized property A will use ",{r,"synthesized"}," instance variable C, not existing instance variable D"}}},
[d]=m,
[e]="autosynthesized property (.*?) will use (?:|synthesized) instance variable (.*?), not existing instance variable (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-autosynthesis\\-property\\-ivar\\-name\\-match[^\\]]*\\]",
[h]=n,
[a]={"63d40202fb47",1340146282,"objective-c: warn when autosynthesizing a property which has same","objective-c: warn when autosynthesizing a property which has same\nname as an existing ivar since this is common source of error\nwhen people remove @synthesize to take advantage of autosynthesis. \n// rdar://11671080\n\nllvm-svn: 158756"},
[i]={{pb,1286,"/// 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 (AtLoc.isInvalid()) {\n // ...\n if (originalIvar) {\n Diag(PropertyDiagLoc, diag::warn_autosynthesis_property_ivar_match) << PropertyId << (Ivar == nullptr) << PropertyIvar << originalIvar->getIdentifier();"}},
[l]={
["clang/test/SemaObjC/default-synthesize-2.m"]={"clang/test/SemaObjC/default-synthesize-2.m:50:1: warning: autosynthesized property \'uid\' will use synthesized instance variable \'_uid\', not existing instance variable \'uid\' [-Wobjc-autosynthesis-property-ivar-name-match]","clang/test/SemaObjC/default-synthesize-2.m:128:1: warning: autosynthesized property \'y\' will use instance variable \'_y\', not existing instance variable \'y\' [-Wobjc-autosynthesis-property-ivar-name-match]"}
}
},
["warn_availability_and_unavailable"]={
[j]={gb},
[k]=gb,
[g]="warn_availability_and_unavailable",
[b]="\'unavailable\' availability overrides all other availability information",
[c]="\'unavailable\' availability overrides all other availability information",
[d]=m,
[e]="\'unavailable\' availability overrides all other availability information",
[f]=fc,
[h]=db,
[a]={"7ab142b55a6e",1301110555,"Extend the new \'availability\' attribute with support for an","Extend the new \'availability\' attribute with support for an\n\'unavailable\' argument, which specifies that the declaration to which\nthe attribute appertains is unavailable on that platform.\n\nllvm-svn: 128329"},
[i]={{Tb,1324,"/// Parse the contents of the \"availability\" attribute.\n///\n/// availability-attribute:\n/// \'availability\' \'(\' platform \',\' opt-strict version-arg-list,\n/// opt-replacement, opt-message\')\'\n///\n/// platform:\n/// identifier\n///\n/// opt-strict:\n/// \'strict\' \',\'\n///\n/// version-arg-list:\n/// version-arg\n/// version-arg \',\' version-arg-list\n///\n/// version-arg:\n/// \'introduced\' \'=\' version\n/// \'deprecated\' \'=\' version\n/// \'obsoleted\' = version\n/// \'unavailable\'\n/// opt-replacement:\n/// \'replacement\' \'=\' <string>\n/// opt-message:\n/// \'message\' \'=\' <string>\nvoid Parser::ParseAvailabilityAttribute(IdentifierInfo &Availability, SourceLocation AvailabilityLoc, ParsedAttributes &attrs, SourceLocation *endLoc, IdentifierInfo *ScopeName, SourceLocation ScopeLoc, ParsedAttr::Form Form) {\n // ...\n // The \'unavailable\' availability cannot be combined with any other\n // availability changes. Make sure that hasn\'t happened.\n if (UnavailableLoc.isValid()) {\n // ...\n for (unsigned Index = Introduced; Index != Unknown; ++Index) {\n if (Changes[Index].KeywordLoc.isValid()) {\n if (!Complained) {\n Diag(UnavailableLoc, diag::warn_availability_and_unavailable) << SourceRange(Changes[Index].KeywordLoc, Changes[Index].VersionRange.getEnd());"}},
[l]={
["clang/test/Parser/attr-availability.c"]={"clang/test/Parser/attr-availability.c:19:50: warning: \'unavailable\' availability overrides all other availability information [-Wavailability]"}
}
},
["warn_availability_fuchsia_unavailable_minor"]={
[j]={gb},
[k]=gb,
[g]={{nil,z,"warn_availability_fuchsia_unavailable_minor"}},
[b]={{nil,z,"Fuchsia API Level prohibits specifying a minor or sub-minor version"}},
[c]={{nil,z,"Fuchsia API Level prohibits specifying a minor or sub-minor version"}},
[d]=m,
[e]="Fuchsia API Level prohibits specifying a minor or sub\\-minor version",
[f]=fc,
[h]={{nil,z,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{o,2651,"static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (II->isStr(\"fuchsia\")) {\n // ...\n if ((Min = Introduced.Version.getMinor()) || (Sub = Introduced.Version.getSubminor())) {\n S.Diag(AL.getLoc(), diag::warn_availability_fuchsia_unavailable_minor);"}},
[l]={
["clang/test/Sema/attr-availability-fuchsia.c"]={"clang/test/Sema/attr-availability-fuchsia.c:17:29: warning: Fuchsia API Level prohibits specifying a minor or sub-minor version [-Wavailability]","clang/test/Sema/attr-availability-fuchsia.c:18:29: warning: Fuchsia API Level prohibits specifying a minor or sub-minor version [-Wavailability]"}
}
},
["warn_availability_on_static_initializer"]={
[j]={gb},
[k]=gb,
[g]={{nil,F,"warn_availability_on_static_initializer"}},
[b]={{nil,F,"ignoring availability attribute %select{on \'+load\' method|with constructor attribute|with destructor attribute}0"}},
[c]={{nil,F,{"ignoring availability attribute ",{"on \'+load\' method","with constructor attribute","with destructor attribute"}}}},
[d]=m,
[e]="ignoring availability attribute (?:on \'\\+load\' method|with constructor attribute|with destructor attribute)",
[f]=fc,
[h]={{nil,F,n}},
[a]={"3bb4aa566e1f",1523921658,"[Availability] Improve availability to consider functions run at load time","[Availability] Improve availability to consider functions run at load time\n\nSummary:\nThere are some functions/methods that run when the application launches\nor the library loads. Those functions will run reguardless the OS\nversion as long as it satifies the minimum deployment target. Annotate\nthem with availability attributes doesn\'t really make sense because they\nare essentially available on all targets since minimum deployment\ntarget.\n\nrdar://problem/36093384\n\nReviewers: arphaman, erik.pilkington\n\nReviewed By: erik.pilkington\n\nSubscribers: erik.pilkington, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D45699\n\nllvm-svn: 330166"},
[i]={{H,10778,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n // ...\n // Diagnose availability attributes. Availability cannot be used on functions\n // that are run during load/unload.\n if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) {\n if (NewFD->hasAttr<ConstructorAttr>()) {\n Diag(attr->getLocation(), diag::warn_availability_on_static_initializer) << 1;"},{H,10783,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n // ...\n // Diagnose availability attributes. Availability cannot be used on functions\n // that are run during load/unload.\n if (const auto *attr = NewFD->getAttr<AvailabilityAttr>()) {\n // ...\n if (NewFD->hasAttr<DestructorAttr>()) {\n Diag(attr->getLocation(), diag::warn_availability_on_static_initializer) << 2;"},{W,5067,"Decl *Sema::ActOnMethodDeclaration(Scope *S, SourceLocation MethodLoc, SourceLocation EndLoc, tok::TokenKind MethodType, ObjCDeclSpec &ReturnQT, ParsedType ReturnType, ArrayRef<SourceLocation> SelectorLocs, Selector Sel,\n // ...\n // + load method cannot have availability attributes. It get called on\n // startup, so it has to have the availability of the deployment target.\n if (const auto *attr = ObjCMethod->getAttr<AvailabilityAttr>()) {\n if (ObjCMethod->isClassMethod() && ObjCMethod->getSelector().getAsString() == \"load\") {\n Diag(attr->getLocation(), diag::warn_availability_on_static_initializer) << 0;"}},
[l]={
["clang/test/SemaObjC/unguarded-availability.m"]={"clang/test/SemaObjC/unguarded-availability.m:361:14: warning: ignoring availability attribute on \'+load\' method [-Wavailability]","clang/test/SemaObjC/unguarded-availability.m:389:1: warning: ignoring availability attribute with constructor attribute [-Wavailability]","clang/test/SemaObjC/unguarded-availability.m:394:1: warning: ignoring availability attribute with destructor attribute [-Wavailability]"}
}
},
["warn_availability_swift_unavailable_deprecated_only"]={
[j]={gb},
[k]=gb,
[g]={{nil,V,"warn_availability_swift_unavailable_deprecated_only"}},
[b]={{nil,V,"only \'unavailable\' and \'deprecated\' are supported for Swift availability"}},
[c]={{nil,V,"only \'unavailable\' and \'deprecated\' are supported for Swift availability"}},
[d]=m,
[e]="only \'unavailable\' and \'deprecated\' are supported for Swift availability",
[f]=fc,
[h]={{nil,V,n}},
[a]={"260e96240297",1541990673,"Support Swift in platform availability attribute","Support Swift in platform availability attribute\n\nSummary: This adds support for Swift platform availability attributes. It\'s largely a port of the changes made to https://github.com/apple/swift-clang/ for Swift availability attributes. Specifically, https://github.com/apple/swift-clang/commit/84b5a21c31cb5b0d7d958a478bc01964939b6952 and https://github.com/apple/swift-clang/commit/e5b87f265aede41c8381094bbf54e2715c8293b0 . The implementation of attribute_availability_swift is a little different and additional tests in test/Index/availability.c were added.\n\nReviewers: manmanren, friss, doug.gregor, arphaman, jfb, erik.pilkington, aaron.ballman\n\nReviewed By: aaron.ballman\n\nSubscribers: aaron.ballman, ColinKinloch, jrmuizel, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D50318\n\nllvm-svn: 346633"},
[i]={{o,2642,"static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (II->isStr(\"swift\")) {\n if (Introduced.isValid() || Obsoleted.isValid() || (!IsUnavailable && !Deprecated.isValid())) {\n S.Diag(AL.getLoc(), diag::warn_availability_swift_unavailable_deprecated_only);"}},
[l]={
["clang/test/Sema/attr-availability-swift.c"]={"clang/test/Sema/attr-availability-swift.c:24:42: warning: only \'unavailable\' and \'deprecated\' are supported for Swift availability [-Wavailability]"}
}
},
["warn_availability_unknown_platform"]={
[j]={gb},
[k]=gb,
[g]="warn_availability_unknown_platform",
[b]="unknown platform %0 in availability macro",
[c]="unknown platform A in availability macro",
[d]=m,
[e]="unknown platform (.*?) in availability macro",
[f]=fc,
[h]=n,
[a]={"20b2ebd78586",1300841403,"Implement a new \'availability\' attribute, that allows one to specify","Implement a new \'availability\' attribute, that allows one to specify\nwhich versions of an OS provide a certain facility. For example,\n\n void foo()\n __attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));\n\nsays that the function \"foo\" was introduced in 10.2, deprecated in\n10.4, and completely obsoleted in 10.6. This attribute ties in with\nthe deployment targets (e.g., -mmacosx-version-min=10.1 specifies that\nwe want to deploy back to Mac OS X 10.1). There are several concrete\nbehaviors that this attribute enables, as illustrated with the\nfunction foo() above:\n\n - If we choose a deployment target >= Mac OS X 10.4, uses of \"foo\"\n will result in a deprecation warning, as if we had placed\n attribute((deprecated)) on it (but with a better diagnostic)\n - If we choose a deployment target >= Mac OS X 10.6, uses of \"foo\"\n will result in an \"unavailable\" warning (in C)/error (in C++), as\n if we had placed attribute((unavailable)) on it\n - If we choose a deployment target prior to 10.2, foo() is\n weak-imported (if it is a kind of entity that can be weak\n imported), as if we had placed the weak_import attribute on it.\n\nNaturally, there can be multiple availability attributes on a\ndeclaration, for different platforms; only the current platform\nmatters when checking availability attributes.\n\nThe only platforms this attribute currently works for are \"ios\" and\n\"macosx\", since we already have -mxxxx-version-min flags for them and we\nhave experience there with macro tricks translating down to the\ndeprecated/unavailable/weak_import attributes. The end goal is to open\nthis up to other platforms, and even extension to other \"platforms\"\nthat are really libraries (say, through a #pragma clang\ndefine_system), but that hasn\'t yet been designed and we may want to\nshake out more issues with this narrower problem first.\n\nAddresses <rdar://problem/6690412>.\n\nAs a drive-by bug-fix, if an entity is both deprecated and\nunavailable, we only emit the \"unavailable\" diagnostic.\n\nllvm-svn: 128127"},
[i]={{o,2619,"static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n if (AvailabilityAttr::getPrettyPlatformName(II->getName()).empty())\n S.Diag(Platform->Loc, diag::warn_availability_unknown_platform) << Platform->Ident;"}},
[l]={
["clang/test/Sema/attr-availability-square-brackets.c"]={"clang/test/Sema/attr-availability-square-brackets.c:25:29: warning: unknown platform \'this\' in availability macro [-Wavailability]"}
}
},
["warn_availability_version_ordering"]={
[j]={gb},
[k]=gb,
[g]="warn_availability_version_ordering",
[b]="feature cannot be %select{introduced|deprecated|obsoleted}0 in %1 version %2 before it was %select{introduced|deprecated|obsoleted}3 in version %4; attribute ignored",
[c]={{nil,nil,{"feature cannot be ",{"introduced",eb,"obsoleted"}," in B version C before it was ",{"introduced",eb,"obsoleted"}," in version E; attribute ignored"}}},
[d]=m,
[e]="feature cannot be (?:introduced|deprecated|obsoleted) in (.*?) version (.*?) before it was (?:introduced|deprecated|obsoleted) in version (.*?); attribute ignored",
[f]=fc,
[h]=n,
[a]={"20b2ebd78586",1300841403,"Implement a new \'availability\' attribute, that allows one to specify","Implement a new \'availability\' attribute, that allows one to specify\nwhich versions of an OS provide a certain facility. For example,\n\n void foo()\n __attribute__((availability(macosx,introduced=10.2,deprecated=10.4,obsoleted=10.6)));\n\nsays that the function \"foo\" was introduced in 10.2, deprecated in\n10.4, and completely obsoleted in 10.6. This attribute ties in with\nthe deployment targets (e.g., -mmacosx-version-min=10.1 specifies that\nwe want to deploy back to Mac OS X 10.1). There are several concrete\nbehaviors that this attribute enables, as illustrated with the\nfunction foo() above:\n\n - If we choose a deployment target >= Mac OS X 10.4, uses of \"foo\"\n will result in a deprecation warning, as if we had placed\n attribute((deprecated)) on it (but with a better diagnostic)\n - If we choose a deployment target >= Mac OS X 10.6, uses of \"foo\"\n will result in an \"unavailable\" warning (in C)/error (in C++), as\n if we had placed attribute((unavailable)) on it\n - If we choose a deployment target prior to 10.2, foo() is\n weak-imported (if it is a kind of entity that can be weak\n imported), as if we had placed the weak_import attribute on it.\n\nNaturally, there can be multiple availability attributes on a\ndeclaration, for different platforms; only the current platform\nmatters when checking availability attributes.\n\nThe only platforms this attribute currently works for are \"ios\" and\n\"macosx\", since we already have -mxxxx-version-min flags for them and we\nhave experience there with macro tricks translating down to the\ndeprecated/unavailable/weak_import attributes. The end goal is to open\nthis up to other platforms, and even extension to other \"platforms\"\nthat are really libraries (say, through a #pragma clang\ndefine_system), but that hasn\'t yet been designed and we may want to\nshake out more issues with this narrower problem first.\n\nAddresses <rdar://problem/6690412>.\n\nAs a drive-by bug-fix, if an entity is both deprecated and\nunavailable, we only emit the \"unavailable\" diagnostic.\n\nllvm-svn: 128127"},
[i]={{o,2398,"static bool checkAvailabilityAttr(Sema &S, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted) {\n // ...\n // Ensure that Introduced <= Deprecated <= Obsoleted (although not all\n // of these steps are needed).\n if (!Introduced.empty() && !Deprecated.empty() && !(Introduced <= Deprecated)) {\n S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) << 1 << PlatformName << Deprecated.getAsString() << 0 << Introduced.getAsString();"},{o,2406,"static bool checkAvailabilityAttr(Sema &S, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted) {\n // ...\n if (!Introduced.empty() && !Obsoleted.empty() && !(Introduced <= Obsoleted)) {\n S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) << 2 << PlatformName << Obsoleted.getAsString() << 0 << Introduced.getAsString();"},{o,2414,"static bool checkAvailabilityAttr(Sema &S, SourceRange Range, IdentifierInfo *Platform, VersionTuple Introduced, VersionTuple Deprecated, VersionTuple Obsoleted) {\n // ...\n if (!Deprecated.empty() && !Obsoleted.empty() && !(Deprecated <= Obsoleted)) {\n S.Diag(Range.getBegin(), diag::warn_availability_version_ordering) << 2 << PlatformName << Obsoleted.getAsString() << 1 << Deprecated.getAsString();"}},
[l]={
["clang/test/Sema/attr-availability-square-brackets.c"]={"clang/test/Sema/attr-availability-square-brackets.c:3:10: warning: feature cannot be deprecated in macOS version 10.2 before it was introduced in version 10.4; attribute ignored [-Wavailability]","clang/test/Sema/attr-availability-square-brackets.c:4:10: warning: feature cannot be obsoleted in iOS version 2.1 before it was deprecated in version 3.0; attribute ignored [-Wavailability]"}
}
},
["warn_avx_calling_convention"]={
[j]={"psabi"},
[k]="psabi",
[g]={{nil,t,"warn_avx_calling_convention"}},
[b]={{nil,t,"AVX vector %select{return|argument}0 of type %1 without \'%2\' enabled changes the ABI"}},
[c]={{nil,t,{"AVX vector ",{"return","argument"}," of type B without \'C\' enabled changes the ABI"}}},
[d]=m,
[e]="AVX vector (?:return|argument) of type (.*?) without \'(.*?)\' enabled changes the ABI",
[f]=" \\[(?:\\-Werror,)?\\-Wpsabi[^\\]]*\\]",
[h]={{nil,t,O}},
[a]={"2831a317b689",1592939649,"Implement AVX ABI Warning/error","Implement AVX ABI Warning/error\n\nThe x86-64 \"avx\" feature changes how >128 bit vector types are passed,\ninstead of being passed in separate 128 bit registers, they can be\npassed in 256 bit registers.\n\n\"avx512f\" does the same thing, except it switches from 256 bit registers\nto 512 bit registers.\n\nThe result of both of these is an ABI incompatibility between functions\ncompiled with and without these features.\n\nThis patch implements a warning/error pair upon an attempt to call a\nfunction that would run afoul of this. First, if a function is called\nthat would have its ABI changed, we issue a warning.\n\nSecond, if said call is made in a situation where the caller and callee\nare known to have different calling conventions (such as the case of\n\'target\'), we instead issue an error.\n\nDifferential Revision: https://reviews.llvm.org/D82562"},
[i]={{"clang/lib/CodeGen/Targets/X86.cpp",1499,"static bool checkAVXParamFeature(DiagnosticsEngine &Diag, SourceLocation CallLoc, const llvm::StringMap<bool> &CallerMap, const llvm::StringMap<bool> &CalleeMap, QualType Ty, StringRef Feature, bool IsArgument) {\n // ...\n if (!CallerHasFeat && !CalleeHasFeat)\n return Diag.Report(CallLoc, diag::warn_avx_calling_convention) << IsArgument << Ty << Feature;"}},
[l]={
["clang/test/CodeGen/convertvector.c"]={"clang/test/CodeGen/convertvector.c:84:12: warning: AVX vector argument of type \'vector8long\' (vector of 8 \'long\' values) without \'avx512f\' enabled changes the ABI [-Wpsabi]"}
}
},
["warn_bad_character_encoding"]={
[j]={"invalid-source-encoding"},
[k]="invalid-source-encoding",
[g]="warn_bad_character_encoding",
[b]="illegal character encoding in character literal",
[c]="illegal character encoding in character literal",
[d]=m,
[e]="illegal character encoding in character literal",
[f]=" \\[(?:\\-Werror,)?\\-Winvalid\\-source\\-encoding[^\\]]*\\]",
[h]=A,
[a]={"9436352a8297",1328936890,"Implement warning for non-wide string literals with an unexpected encoding. Downgrade error for non...","Implement warning for non-wide string literals with an unexpected encoding. Downgrade error for non-wide character literals with an unexpected encoding to a warning for compatibility with gcc and older versions of clang. <rdar://problem/10837678>.\n\nllvm-svn: 150295"},
[i]={{Dc,1747,"/// \\verbatim\n/// user-defined-character-literal: [C++11 lex.ext]\n/// character-literal ud-suffix\n/// ud-suffix:\n/// identifier\n/// character-literal: [C++11 lex.ccon]\n/// \' c-char-sequence \'\n/// u\' c-char-sequence \'\n/// U\' c-char-sequence \'\n/// L\' c-char-sequence \'\n/// u8\' c-char-sequence \' [C++1z lex.ccon]\n/// c-char-sequence:\n/// c-char\n/// c-char-sequence c-char\n/// c-char:\n/// any member of the source character set except the single-quote \',\n/// backslash \\, or new-line character\n/// escape-sequence\n/// universal-character-name\n/// escape-sequence:\n/// simple-escape-sequence\n/// octal-escape-sequence\n/// hexadecimal-escape-sequence\n/// simple-escape-sequence:\n/// one of \\\' \\\" \\? \\\\ \\a \\b \\f \\n \\r \\t \\v\n/// octal-escape-sequence:\n/// \\ octal-digit\n/// \\ octal-digit octal-digit\n/// \\ octal-digit octal-digit octal-digit\n/// hexadecimal-escape-sequence:\n/// \\x hexadecimal-digit\n/// hexadecimal-escape-sequence hexadecimal-digit\n/// universal-character-name: [C++11 lex.charset]\n/// \\u hex-quad\n/// \\U hex-quad hex-quad\n/// hex-quad:\n/// hex-digit hex-digit hex-digit hex-digit\n/// \\endverbatim\n///\nCharLiteralParser::CharLiteralParser(const char *begin, const char *end, SourceLocation Loc, Preprocessor &PP, tok::TokenKind kind) {\n // ...\n while (begin != end) {\n // Is this a span of non-escape characters?\n if (begin[0] != \'\\\\\') {\n // ...\n if (res != llvm::conversionOK) {\n // ...\n if (NoErrorOnBadEncoding)\n Msg = diag::warn_bad_character_encoding;"}},
[l]={
["clang/test/Lexer/char-literal-encoding-error.c"]={"clang/test/Lexer/char-literal-encoding-error.c:6:9: warning: illegal character encoding in character literal [-Winvalid-source-encoding]","clang/test/Lexer/char-literal-encoding-error.c:13:32: warning: illegal character encoding in character literal [-Winvalid-source-encoding]","clang/test/Lexer/char-literal-encoding-error.c:14:17: warning: illegal character encoding in character literal [-Winvalid-source-encoding]"}
}
},
["warn_bad_cxx_cast_nested_pointer_addr_space"]={
[j]={"incompatible-pointer-types","incompatible-pointer-types-discards-qualifiers"},
[k]="incompatible-pointer-types-discards-qualifiers",
[g]={{nil,s,"warn_bad_cxx_cast_nested_pointer_addr_space"}},
[b]={{nil,s,"%select{reinterpret_cast|C-style cast}0 from %1 to %2 changes address space of nested pointers"}},
[c]={{nil,s,{{"reinterpret_cast","C-style cast"}," from B to C changes address space of nested pointers"}}},
[d]=m,
[e]="(?:reinterpret_cast|C\\-style cast) from (.*?) to (.*?) changes address space of nested pointers",
[f]=" \\[(?:\\-Werror,)?\\-Wincompatible\\-pointer\\-types\\-discards\\-qualifiers[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"1228d42ddab8",1576809732,"[OpenMP][Part 2] Use reusable OpenMP context/traits handling","[OpenMP][Part 2] Use reusable OpenMP context/traits handling\n\nThis patch implements an almost complete handling of OpenMP\ncontexts/traits such that we can reuse most of the logic in Flang\nthrough the OMPContext.{h,cpp} in llvm/Frontend/OpenMP.\n\nAll but construct SIMD specifiers, e.g., inbranch, and the device ISA\nselector are define in `llvm/lib/Frontend/OpenMP/OMPKinds.def`. From\nthese definitions we generate the enum classes `TraitSet`,\n`TraitSelector`, and `TraitProperty` as well as conversion and helper\nfunctions in `llvm/lib/Frontend/OpenMP/OMPContext.{h,cpp}`.\n\nThe above enum classes are used in the parser, sema, and the AST\nattribute. The latter is not a collection of multiple primitive variant\narguments that contain encodings via numbers and strings but instead a\ntree that mirrors the `match` clause (see `struct OpenMPTraitInfo`).\n\nThe changes to the parser make it more forgiving when wrong syntax is\nread and they also resulted in more specialized diagnostics. The tests\nare updated and the core issues are detected as before. Here and\nelsewhere this patch tries to be generic, thus we do not distinguish\nwhat selector set, selector, or property is parsed except if they do\nbehave exceptionally, as for example `user={condition(EXPR)}` does.\n\nThe sema logic changed in two ways: First, the OMPDeclareVariantAttr\nrepresentation changed, as mentioned above, and the sema was adjusted to\nwork with the new `OpenMPTraitInfo`. Second, the matching and scoring\nlogic moved into `OMPContext.{h,cpp}`. It is implemented on a flat\nrepresentation of the `match` clause that is not tied to clang.\n`OpenMPTraitInfo` provides a method to generate this flat structure (see\n`struct VariantMatchInfo`) by computing integer score values and boolean\nuser conditions from the `clang::Expr` we keep for them.\n\nThe OpenMP context is now an explicit object (see `struct OMPContext`).\nThis is in anticipation of construct traits that need to be tracked. The\nOpenMP context, as well as the `VariantMatchInfo`, are basically made up\nof a set of active or respectively required traits, e.g., \'host\', and an\nordered container of constructs which allows duplication. Matching and\nscoring is kept as generic as possible to allow easy extension in the\nfuture.\n\n---\n\nTest changes:\n\nThe messages checked in `OpenMP/declare_variant_messages.{c,cpp}` have\nbeen auto generated to match the new warnings and notes of the parser.\nThe \"subset\" checks were reversed causing the wrong version to be\npicked. The tests have been adjusted to correct this.\nWe do not print scores if the user did not provide one.\nWe print spaces to make lists in the `match` clause more legible.\n\nReviewers: kiranchandramohan, ABataev, RaviNarayanaswamy, gtbercea, grokos, sdmitriev, JonChesterfield, hfinkel, fghanim\n\nSubscribers: merge_guards_bot, rampitec, mgorny, hiraditya, aheejin, fedor.sergeev, simoncook, bollu, guansong, dexonsmith, jfb, s.egerton, llvm-commits, cfe-commits\n\nTags: #clang, #llvm\n\nDifferential Revision: https://reviews.llvm.org/D71830"},
[i]={{mb,2583,"static TryCastResult TryReinterpretCast(Sema &Self, ExprResult &SrcExpr, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind) {\n // ...\n while (!DestPtee.isNull() && !SrcPtee.isNull()) {\n if (DestPtee.getAddressSpace() != SrcPtee.getAddressSpace()) {\n Self.Diag(OpRange.getBegin(), diag::warn_bad_cxx_cast_nested_pointer_addr_space) << CStyle << SrcType << DestType << SrcExpr.get()->getSourceRange();"}},
[l]={
["clang/test/SemaOpenCLCXX/address-space-castoperators.clcpp"]={"clang/test/SemaOpenCLCXX/address-space-castoperators.clcpp:11:12: warning: reinterpret_cast from \'__local int *__generic *\' to \'__generic int *__generic *\' changes address space of nested pointers [-Wincompatible-pointer-types-discards-qualifiers]","clang/test/SemaOpenCLCXX/address-space-castoperators.clcpp:16:12: warning: reinterpret_cast from \'__constant int *__generic *\' to \'__generic int *__generic *\' changes address space of nested pointers [-Wincompatible-pointer-types-discards-qualifiers]"}
}
},
["warn_bad_function_cast"]={
[j]={"bad-function-cast"},
[k]="bad-function-cast",
[g]="warn_bad_function_cast",
[b]="cast from function call of type %0 to non-matching type %1",
[c]="cast from function call of type A to non-matching type B",
[d]=m,
[e]="cast from function call of type (.*?) to non\\-matching type (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wbad\\-function\\-cast[^\\]]*\\]",
[h]=n,
[a]={"91f548b04b7d",1345224154,"c: implement gcc\'s -Wbad-function-cast which warns","c: implement gcc\'s -Wbad-function-cast which warns\non unsafe cast of a c-function call. This is\na C-only option.\n\nllvm-svn: 162109"},
[i]={{mb,2877,"/// DiagnoseBadFunctionCast - Warn whenever a function call is cast to a\n/// non-matching type. Such as enum function call to int, int call to\n/// pointer; etc. Cast to \'void\' is an exception.\nstatic void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n if (Self.Diags.isIgnored(diag::warn_bad_function_cast, SrcExpr.get()->getExprLoc()))"},{mb,2906,"/// DiagnoseBadFunctionCast - Warn whenever a function call is cast to a\n/// non-matching type. Such as enum function call to int, int call to\n/// pointer; etc. Cast to \'void\' is an exception.\nstatic void DiagnoseBadFunctionCast(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n Self.Diag(SrcExpr.get()->getExprLoc(), diag::warn_bad_function_cast) << SrcType << DestType << SrcExpr.get()->getSourceRange();"}},
[l]={
["clang/test/Sema/warn-bad-function-cast.c"]={"clang/test/Sema/warn-bad-function-cast.c:42:10: warning: cast from function call of type \'int\' to non-matching type \'float\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:43:11: warning: cast from function call of type \'char\' to non-matching type \'double\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:44:10: warning: cast from function call of type \'long\' to non-matching type \'_Bool\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:45:8: warning: cast from function call of type \'float\' to non-matching type \'int\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:46:9: warning: cast from function call of type \'double\' to non-matching type \'long\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:47:11: warning: cast from function call of type \'_Complex double\' to non-matching type \'double\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:48:8: warning: cast from function call of type \'enum e\' to non-matching type \'int\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:49:8: warning: cast from function call of type \'_Bool\' to non-matching type \'int\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:50:18: warning: cast from function call of type \'char *\' to non-matching type \'unsigned long\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:51:21: warning: cast from function call of type \'int *\' to non-matching type \'long\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:52:12: warning: cast from function call of type \'int\' to non-matching type \'_Fract\' [-Wbad-function-cast]","clang/test/Sema/warn-bad-function-cast.c:53:8: warning: cast from function call of type \'_Fract\' to non-matching type \'int\' [-Wbad-function-cast]"}
}
},
["warn_bad_receiver_type"]={
[j]={"receiver-expr"},
[k]="receiver-expr",
[g]="warn_bad_receiver_type",
[b]="receiver type %0 is not \'id\' or interface pointer, consider casting it to \'id\'",
[c]="receiver type A is not \'id\' or interface pointer, consider casting it to \'id\'",
[d]=m,
[e]="receiver type (.*?) is not \'id\' or interface pointer, consider casting it to \'id\'",
[f]=" \\[(?:\\-Werror,)?\\-Wreceiver\\-expr[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{ec,2914,"/// Build an Objective-C instance message expression.\n///\n/// This routine takes care of both normal instance messages and\n/// instance messages to the superclass instance.\n///\n/// \\param Receiver The expression that computes the object that will\n/// receive this message. This may be empty, in which case we are\n/// sending to the superclass instance and \\p SuperLoc must be a valid\n/// source location.\n///\n/// \\param ReceiverType The (static) type of the object receiving the\n/// message. When a \\p Receiver expression is provided, this is the\n/// same type as that expression. For a superclass instance send, this\n/// is a pointer to the type of the superclass.\n///\n/// \\param SuperLoc The location of the \"super\" keyword in a\n/// superclass instance message.\n///\n/// \\param Sel The selector to which the message is being sent.\n///\n/// \\param Method The method that this instance message is invoking, if\n/// already known.\n///\n/// \\param LBracLoc The location of the opening square bracket \']\'.\n///\n/// \\param RBracLoc The location of the closing square bracket \']\'.\n///\n/// \\param ArgsIn The message arguments.\nExprResult Sema::BuildInstanceMessage(Expr *Receiver, QualType ReceiverType, SourceLocation SuperLoc, Selector Sel, ObjCMethodDecl *Method, SourceLocation LBracLoc, ArrayRef<SourceLocation> SelectorLocs, SourceLocation RBracLoc, MultiExprArg ArgsIn, bool isImplicit) {\n // ...\n // If we have a receiver expression, perform appropriate promotions\n // and determine receiver type.\n if (Receiver) {\n // ...\n // If the receiver is an ObjC pointer, a block pointer, or an\n // __attribute__((NSObject)) pointer, we don\'t need to do any\n // special conversion in order to look up a receiver.\n if (ReceiverType->isObjCRetainableType()) {\n // ...\n } else if (!getLangOpts().ObjCAutoRefCount && !Context.getObjCIdType().isNull() && (ReceiverType->isPointerType() || ReceiverType->isIntegerType())) {\n // ...\n Diag(Loc, diag::warn_bad_receiver_type) << ReceiverType << RecRange;"}},
[l]={
["clang/test/SemaObjC/deprecated-objc-introspection.m"]={"clang/test/SemaObjC/deprecated-objc-introspection.m:38:4: warning: receiver type \'struct objc_class *\' is not \'id\' or interface pointer, consider casting it to \'id\' [-Wreceiver-expr]","clang/test/SemaObjC/deprecated-objc-introspection.m:40:4: warning: receiver type \'struct objc_class *\' is not \'id\' or interface pointer, consider casting it to \'id\' [-Wreceiver-expr]"}
}
},
["warn_bad_string_encoding"]={
[j]={"invalid-source-encoding"},
[k]="invalid-source-encoding",
[g]="warn_bad_string_encoding",
[b]="illegal character encoding in string literal",
[c]="illegal character encoding in string literal",
[d]=m,
[e]="illegal character encoding in string literal",
[f]=" \\[(?:\\-Werror,)?\\-Winvalid\\-source\\-encoding[^\\]]*\\]",
[h]=A,
[a]={"9436352a8297",1328936890,"Implement warning for non-wide string literals with an unexpected encoding. Downgrade error for non...","Implement warning for non-wide string literals with an unexpected encoding. Downgrade error for non-wide character literals with an unexpected encoding to a warning for compatibility with gcc and older versions of clang. <rdar://problem/10837678>.\n\nllvm-svn: 150295"},
[i]={{Dc,2264,"/// This function copies from Fragment, which is a sequence of bytes\n/// within Tok\'s contents (which begin at TokBegin) into ResultPtr.\n/// Performs widening for multi-byte characters.\nbool StringLiteralParser::CopyStringFragment(const Token &Tok, const char *TokBegin, StringRef Fragment) {\n // ...\n if (Diags) {\n // ...\n const DiagnosticBuilder &Builder = Diag(Diags, Features, SourceLoc, TokBegin, ErrorPtr, resyncUTF8(ErrorPtr, Fragment.end()), NoErrorOnBadEncoding ? diag::warn_bad_string_encoding : diag::err_bad_string_encoding);"}},
[l]={
["clang/test/Lexer/string-literal-encoding.c"]={"clang/test/Lexer/string-literal-encoding.c:16:22: warning: illegal character encoding in string literal [-Winvalid-source-encoding]","clang/test/Lexer/string-literal-encoding.c:18:24: warning: illegal character encoding in string literal [-Winvalid-source-encoding]","clang/test/Lexer/string-literal-encoding.c:30:26: warning: illegal character encoding in string literal [-Winvalid-source-encoding]","clang/test/Lexer/string-literal-encoding.c:32:28: warning: illegal character encoding in string literal [-Winvalid-source-encoding]"}
}
},
["warn_base_class_is_uninit"]={
[j]={P,T,cb,"uninitialized"},
[k]="uninitialized",
[g]="warn_base_class_is_uninit",
[b]="base class %0 is uninitialized when used here to access %q1",
[c]="base class A is uninitialized when used here to access B",
[d]=m,
[e]="base class (.*?) is uninitialized when used here to access (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wuninitialized[^\\]]*\\]",
[h]=n,
[a]={"3630c399727a",1416539430,"Extend -Wuninitialized to warn when accessing uninitialized base classes in a","Extend -Wuninitialized to warn when accessing uninitialized base classes in a\nconstructor.\n\nllvm-svn: 222503"},
[i]={{C,3836,"class UninitializedFieldVisitor : public EvaluatedExprVisitor<UninitializedFieldVisitor> {\n // ...\n void HandleMemberExpr(MemberExpr *ME, bool CheckReferenceOnly, bool AddressOf) {\n // ...\n if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {\n // ...\n if (BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {\n // ...\n if (T->isPointerType() && BaseClasses.count(T->getPointeeType())) {\n S.Diag(FieldME->getExprLoc(), diag::warn_base_class_is_uninit) << T->getPointeeType() << FoundVD;"}},
[l]={
["clang/test/SemaCXX/uninitialized.cpp"]={"clang/test/SemaCXX/uninitialized.cpp:1380:21: warning: base class \'base_class_access::A\' is uninitialized when used here to access \'base_class_access::A::i\' [-Wuninitialized]","clang/test/SemaCXX/uninitialized.cpp:1383:21: warning: base class \'base_class_access::A\' is uninitialized when used here to access \'base_class_access::A::foo\' [-Wuninitialized]","clang/test/SemaCXX/uninitialized.cpp:1395:21: warning: base class \'base_class_access::A\' is uninitialized when used here to access \'base_class_access::A::i\' [-Wuninitialized]","clang/test/SemaCXX/uninitialized.cpp:1398:21: warning: base class \'base_class_access::A\' is uninitialized when used here to access \'base_class_access::A::foo\' [-Wuninitialized]"}
}
},
["warn_bind_ref_member_to_parameter"]={
[j]={"dangling","dangling-field"},
[k]="dangling-field",
[g]="warn_bind_ref_member_to_parameter",
[b]={{nil,F,"binding reference member %0 to stack allocated %select{variable|parameter}2 %1"},{N,nil,"binding reference member %0 to stack allocated parameter %1"}},
[c]={{nil,F,{"binding reference member A to stack allocated ",{Kc,"parameter"}," B"}},{N,nil,"binding reference member A to stack allocated parameter B"}},
[d]=m,
[e]="binding reference member (.*?) to stack allocated (?:variable|parameter) (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wdangling\\-field[^\\]]*\\]",
[h]=n,
[a]={"599deef37946",1315012455,"Add a simple new warning to catch blatantly dangling pointer and","Add a simple new warning to catch blatantly dangling pointer and\nreference members of classes. We\'ve had several bugs reported because of\nthis, and there\'s no reason not to flag it right away in the compiler.\n\nComments especially welcome on the strategy for implementing this\nwarning (IE, what should trigger this?) and on the text of the warning\nitself.\n\nI\'m going to extend this to cover obvious cases with temporaries and\nbeef up the test cases some in subsequent patches. I\'ll then run it over\na large codebase and make sure its not misbehaving before I add it to\n-Wall or turn it on by default. I think this one might be a good\ncandidate for on by default.\n\nllvm-svn: 139075"},
[i]={{Rb,8226,"void Sema::checkInitializerLifetime(const InitializedEntity &Entity, Expr *Init) {\n // ...\n auto TemporaryVisitor = [&](IndirectLocalPath &Path, Local L, ReferenceKind RK) -> bool {\n // ...\n case LK_MemInitializer: {\n if (isa<MaterializeTemporaryExpr>(L)) {\n // ...\n } else {\n // ...\n if (auto *Member = ExtendingEntity ? ExtendingEntity->getDecl() : nullptr) {\n // ...\n Diag(DiagLoc, IsPointer ? diag::warn_init_ptr_member_to_parameter_addr : diag::warn_bind_ref_member_to_parameter) << Member << VD << isa<ParmVarDecl>(VD) << DiagRange;"}},
[l]={
["clang/test/SemaCXX/warn-dangling-field.cpp"]={"clang/test/SemaCXX/warn-dangling-field.cpp:15:9: warning: binding reference member \'x\' to stack allocated parameter \'i\' [-Wdangling-field]","clang/test/SemaCXX/warn-dangling-field.cpp:33:17: warning: binding reference member \'x\' to stack allocated parameter \'i\' [-Wdangling-field]"}
}
},
["warn_binding_null_to_reference"]={
[j]={"null-dereference"},
[k]="null-dereference",
[g]="warn_binding_null_to_reference",
[b]="binding dereferenced null pointer to reference has undefined behavior",
[c]="binding dereferenced null pointer to reference has undefined behavior",
[d]=m,
[e]="binding dereferenced null pointer to reference has undefined behavior",
[f]=" \\[(?:\\-Werror,)?\\-Wnull\\-dereference[^\\]]*\\]",
[h]=n,
[a]={"2eeddfb1efc8",1463247854,"Warn when a reference is bound to an empty l-value (dereferenced null pointer).","Warn when a reference is bound to an empty l-value (dereferenced null pointer).\n\nllvm-svn: 269572"},
[i]={{Rb,8453,"static void CheckForNullPointerDereference(Sema &S, const Expr *E) {\n // Check to see if we are dereferencing a null pointer. If so, this is\n // undefined behavior, so warn about it. This only handles the pattern\n // \"*null\", which is a very syntactic check.\n if (const UnaryOperator *UO = dyn_cast<UnaryOperator>(E->IgnoreParenCasts()))\n if (UO->getOpcode() == UO_Deref && UO->getSubExpr()->IgnoreParenCasts()->isNullPointerConstant(S.Context, Expr::NPC_ValueDependentIsNotNull)) {\n S.DiagRuntimeBehavior(UO->getOperatorLoc(), UO, S.PDiag(diag::warn_binding_null_to_reference) << UO->getSubExpr()->getSourceRange());"}},
[l]={
["clang/test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp"]={"clang/test/CXX/expr/expr.prim/expr.prim.lambda/p5.cpp:14:35: warning: binding dereferenced null pointer to reference has undefined behavior [-Wnull-dereference]"}
}
},
["warn_bitfield_too_small_for_enum"]={
[j]={"bitfield-enum-conversion",Bb,Cb},
[k]="bitfield-enum-conversion",
[g]={{nil,E,"warn_bitfield_too_small_for_enum"}},
[b]={{nil,E,"bit-field %0 is not wide enough to store all enumerators of %1"}},
[c]={{nil,E,"bit-field A is not wide enough to store all enumerators of B"}},
[d]=m,
[e]="bit\\-field (.*?) is not wide enough to store all enumerators of (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wbitfield\\-enum\\-conversion[^\\]]*\\]",
[h]={{nil,E,ac}},
[a]={"329f24d6f6e7",1489514462,"Warn on enum assignment to bitfields that can\'t fit all values","Warn on enum assignment to bitfields that can\'t fit all values\n\nThis adds -Wbitfield-enum-conversion, which warns on implicit\nconversions that happen on bitfield assignment that change the value of\nsome enumerators.\n\nValues of enum type typically take on a very small range of values, so\nthey are frequently stored in bitfields. Unfortunately, there is no\nconvenient way to calculate the minimum number of bits necessary to\nstore all possible values at compile time, so users usually hard code a\nbitwidth that works today and widen it as necessary to pass basic\ntesting and validation. This is very error-prone, and leads to stale\nwidths as enums grow. This warning aims to catch such bugs.\n\nThis would have found two real bugs in clang and two instances of\nquestionable code. See r297680 and r297654 for the full description of\nthe issues.\n\nThis warning is currently disabled by default while we investigate its\nusefulness outside of LLVM.\n\nThe major cause of false positives with this warning is this kind of\nenum:\n enum E { W, X, Y, Z, SENTINEL_LAST };\nThe last enumerator is an invalid value used to validate inputs or size\nan array. Depending on the prevalance of this style of enum across a\ncodebase, this warning may be more or less feasible to deploy. It also\nhas trouble on sentinel values such as ~0U.\n\nReviewers: rsmith, rtrieu, thakis\n\nReviewed By: thakis\n\nSubscribers: hfinkel, voskresensky.vladimir, sashab, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D30923\n\nllvm-svn: 297761"},
[i]={{u,14109,"/// Analyzes an attempt to assign the given value to a bitfield.\n///\n/// Returns true if there was something fishy about the attempt.\nstatic bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc) {\n // ...\n if (!OriginalInit->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects)) {\n // The RHS is not constant. If the RHS has an enum type, make sure the\n // bitfield is wide enough to hold all the values of the enum without\n // truncation.\n if (const auto *EnumTy = OriginalInit->getType()->getAs<EnumType>()) {\n // ...\n // Check the bitwidth.\n if (BitsNeeded > FieldWidth) {\n // ...\n S.Diag(InitLoc, diag::warn_bitfield_too_small_for_enum) << Bitfield << ED;"}},
[l]={
["clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp"]={"clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:28:14: warning: bit-field \'two_bits\' is not wide enough to store all enumerators of \'ThreeBits\' [-Wbitfield-enum-conversion]","clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:29:14: warning: bit-field \'two_bits\' is not wide enough to store all enumerators of \'ThreeBitsSigned\' [-Wbitfield-enum-conversion]","clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:34:21: warning: bit-field \'two_bits_signed\' is not wide enough to store all enumerators of \'ThreeBits\' [-Wbitfield-enum-conversion]","clang/test/SemaCXX/warn-bitfield-enum-conversion.cpp:35:21: warning: bit-field \'two_bits_signed\' is not wide enough to store all enumerators of \'ThreeBitsSigned\' [-Wbitfield-enum-conversion]"}
}
},
["warn_bitfield_width_exceeds_type_width"]={
[j]={"bitfield-width"},
[k]="bitfield-width",
[g]="warn_bitfield_width_exceeds_type_width",
[b]="width of bit-field %0 (%1 bits) exceeds the width of its type; value will be truncated to %2 bit%s2",
[c]="width of bit-field A (B bits) exceeds the width of its type; value will be truncated to C bitC",
[d]=m,
[e]="width of bit\\-field (.*?) \\((.*?) bits\\) exceeds the width of its type; value will be truncated to (.*?) bit(.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wbitfield\\-width[^\\]]*\\]",
[h]=n,
[a]={"022bdc7d7361",1442266056,"C11 _Bool bitfield diagnostic","C11 _Bool bitfield diagnostic\n\nSummary: Implement DR262 (for C). This patch will mainly affect bitfields of type _Bool\n\nReviewers: fraggamuffin, rsmith\n\nSubscribers: hubert.reinterpretcast, cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D10018\n\nllvm-svn: 247618"},
[i]={{H,17961,"// Note that FieldName may be null for anonymous bitfields.\nExprResult Sema::VerifyBitField(SourceLocation FieldLoc, IdentifierInfo *FieldName, QualType FieldTy, bool IsMsStruct, Expr *BitWidth) {\n // ...\n if (!FieldTy->isDependentType()) {\n // ...\n // Warn on types where the user might conceivably expect to get all\n // specified bits as value bits: that\'s all integral types other than\n // \'bool\'.\n if (BitfieldIsOverwide && !FieldTy->isBooleanType() && FieldName) {\n Diag(FieldLoc, diag::warn_bitfield_width_exceeds_type_width) << FieldName << toString(Value, 10) << (unsigned)TypeWidth;"}},
[l]={
["clang/test/SemaCXX/bitfield-layout.cpp"]={"clang/test/SemaCXX/bitfield-layout.cpp:8:8: warning: width of bit-field \'c\' (9 bits) exceeds the width of its type; value will be truncated to 8 bits [-Wbitfield-width]","clang/test/SemaCXX/bitfield-layout.cpp:20:8: warning: width of bit-field \'c\' (16 bits) exceeds the width of its type; value will be truncated to 8 bits [-Wbitfield-width]","clang/test/SemaCXX/bitfield-layout.cpp:26:8: warning: width of bit-field \'c\' (32 bits) exceeds the width of its type; value will be truncated to 8 bits [-Wbitfield-width]","clang/test/SemaCXX/bitfield-layout.cpp:32:8: warning: width of bit-field \'c\' (64 bits) exceeds the width of its type; value will be truncated to 8 bits [-Wbitfield-width]","clang/test/SemaCXX/bitfield-layout.cpp:38:8: warning: width of bit-field \'c\' (4294967297 bits) exceeds the width of its type; value will be truncated to 8 bits [-Wbitfield-width]"}
}
},
["warn_bitwise_instead_of_logical"]={
[j]={P,T,"bitwise-instead-of-logical","bool-operation",cb},
[k]="bitwise-instead-of-logical",
[g]={{nil,z,"warn_bitwise_instead_of_logical"}},
[b]={{nil,z,"use of bitwise \'%0\' with boolean operands"}},
[c]={{nil,z,"use of bitwise \'A\' with boolean operands"}},
[d]=m,
[e]="use of bitwise \'(.*?)\' with boolean operands",
[f]=" \\[(?:\\-Werror,)?\\-Wbitwise\\-instead\\-of\\-logical[^\\]]*\\]",
[h]={{nil,z,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{u,15248,"/// Data recursive variant of AnalyzeImplicitConversions. Subexpressions\n/// that should be visited are added to WorkList.\nstatic void AnalyzeImplicitConversions(Sema &S, AnalyzeImplicitConversionsWorkItem Item, llvm::SmallVectorImpl<AnalyzeImplicitConversionsWorkItem> &WorkList) {\n // ...\n if (const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))\n if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) && BO->getLHS()->isKnownToHaveBooleanValue() && BO->getRHS()->isKnownToHaveBooleanValue() && BO->getLHS()->HasSideEffects(S.Context) && BO->getRHS()->HasSideEffects(S.Context)) {\n S.Diag(BO->getBeginLoc(), diag::warn_bitwise_instead_of_logical) << (BO->getOpcode() == BO_And ? \"&\" : \"|\") << OrigE->getSourceRange() << FixItHint::CreateReplacement(BO->getOperatorLoc(), (BO->getOpcode() == BO_And ? \"&&\" : \"||\"));"}},
[l]={
["clang/test/Sema/warn-bitwise-or-bool.c"]={"clang/test/Sema/warn-bitwise-or-bool.c:27:7: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]","clang/test/Sema/warn-bitwise-or-bool.c:32:7: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]","clang/test/Sema/warn-bitwise-or-bool.c:35:7: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]","clang/test/Sema/warn-bitwise-or-bool.c:40:7: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]","clang/test/Sema/warn-bitwise-or-bool.c:48:7: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]","clang/test/Sema/warn-bitwise-or-bool.c:52:7: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]","clang/test/Sema/warn-bitwise-or-bool.c:58:8: warning: use of bitwise \'|\' with boolean operands [-Wbitwise-instead-of-logical]"}
}
},
["warn_bitwise_negation_bool"]={
[j]={P,T,"bool-operation",cb},
[k]="bool-operation",
[g]={{nil,s,"warn_bitwise_negation_bool"}},
[b]={{nil,s,"bitwise negation of a boolean expression%select{;| always evaluates to \'true\';}0 did you mean logical negation?"}},
[c]={{nil,s,{"bitwise negation of a boolean expression",{";"," always evaluates to \'true\';"}," did you mean logical negation?"}}},
[d]=m,
[e]="bitwise negation of a boolean expression(?:;| always evaluates to \'true\';) did you mean logical negation\\?",
[f]=" \\[(?:\\-Werror,)?\\-Wbool\\-operation[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"7c11da0cfd33",1567434909,"[clang] New __attribute__((__clang_arm_mve_alias)).","[clang] New __attribute__((__clang_arm_mve_alias)).\n\nThis allows you to declare a function with a name of your choice (say\n`foo`), but have clang treat it as if it were a builtin function (say\n`__builtin_foo`), by writing\n\n static __inline__ __attribute__((__clang_arm_mve_alias(__builtin_foo)))\n int foo(args);\n\nI\'m intending to use this for the ACLE intrinsics for MVE, which have\nto be polymorphic on their argument types and also need to be\nimplemented by builtins. To avoid having to implement the polymorphism\nwith several layers of nested _Generic and make error reporting\nhideous, I want to make all the user-facing intrinsics correspond\ndirectly to clang builtins, so that after clang resolves\n__attribute__((overloadable)) polymorphism it\'s already holding the\nright BuiltinID for the intrinsic it selected.\n\nHowever, this commit itself just introduces the new attribute, and\ndoesn\'t use it for anything.\n\nTo avoid unanticipated side effects if this attribute is used to make\naliases to other builtins, there\'s a restriction mechanism: only\n(BuiltinID, alias) pairs that are approved by the function\nArmMveAliasValid() will be permitted. At present, that function\ndoesn\'t permit anything, because the Tablegen that will generate its\nlist of valid pairs isn\'t yet implemented. So the only test of this\nfacility is one that checks that an unapproved builtin _can\'t_ be\naliased.\n\nReviewers: dmgreen, miyuki, ostannard\n\nSubscribers: cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D67159"},
[i]={{u,15238,"/// Data recursive variant of AnalyzeImplicitConversions. Subexpressions\n/// that should be visited are added to WorkList.\nstatic void AnalyzeImplicitConversions(Sema &S, AnalyzeImplicitConversionsWorkItem Item, llvm::SmallVectorImpl<AnalyzeImplicitConversionsWorkItem> &WorkList) {\n // ...\n if (const auto *UO = dyn_cast<UnaryOperator>(SourceExpr))\n if (UO->getOpcode() == UO_Not && UO->getSubExpr()->isKnownToHaveBooleanValue())\n S.Diag(UO->getBeginLoc(), diag::warn_bitwise_negation_bool) << OrigE->getSourceRange() << T->isBooleanType() << FixItHint::CreateReplacement(UO->getBeginLoc(), \"!\");"}},
[l]={
["clang/test/Sema/warn-bitwise-negation-bool.c"]={"clang/test/Sema/warn-bitwise-negation-bool.c:15:7: warning: bitwise negation of a boolean expression always evaluates to \'true\'; did you mean logical negation? [-Wbool-operation]","clang/test/Sema/warn-bitwise-negation-bool.c:17:7: warning: bitwise negation of a boolean expression always evaluates to \'true\'; did you mean logical negation? [-Wbool-operation]","clang/test/Sema/warn-bitwise-negation-bool.c:20:7: warning: bitwise negation of a boolean expression; did you mean logical negation? [-Wbool-operation]","clang/test/Sema/warn-bitwise-negation-bool.c:22:7: warning: bitwise negation of a boolean expression always evaluates to \'true\'; did you mean logical negation? [-Wbool-operation]"}
}
},
["warn_bitwise_op_in_bitwise_op"]={
[j]={P,T,"bitwise-op-parentheses","parentheses"},
[k]="bitwise-op-parentheses",
[g]="warn_bitwise_op_in_bitwise_op",
[b]="\'%0\' within \'%1\'",
[c]="\'A\' within \'B\'",
[d]=m,
[e]="\'(.*?)\' within \'(.*?)\'",
[f]=" \\[(?:\\-Werror,)?\\-Wbitwise\\-op\\-parentheses[^\\]]*\\]",
[h]=n,
[a]={"84543b09cb28",1449985301,"[Sema] Add -Wparentheses warnings for \'^\' in \'|\' expressions and \'&\' in \'^\' expressions to complimen...","[Sema] Add -Wparentheses warnings for \'^\' in \'|\' expressions and \'&\' in \'^\' expressions to compliment \'&\' in \'|\' that is already present. Matches gcc behavior.\n\nllvm-svn: 255450"},
[i]={{G,15831,"/// Look for bitwise op in the left or right hand of a bitwise op with\n/// lower precedence and emit a diagnostic together with a fixit hint that wraps\n/// the \'&\' expression in parentheses.\nstatic void DiagnoseBitwiseOpInBitwiseOp(Sema &S, BinaryOperatorKind Opc, SourceLocation OpLoc, Expr *SubExpr) {\n if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(SubExpr)) {\n if (Bop->isBitwiseOp() && Bop->getOpcode() < Opc) {\n S.Diag(Bop->getOperatorLoc(), diag::warn_bitwise_op_in_bitwise_op) << Bop->getOpcodeStr() << BinaryOperator::getOpcodeStr(Opc) << Bop->getSourceRange() << OpLoc;"}},
[l]={
["clang/test/Sema/bitwise-op-parentheses.c"]={"clang/test/Sema/bitwise-op-parentheses.c:11:12: warning: \'&\' within \'|\' [-Wbitwise-op-parentheses]","clang/test/Sema/bitwise-op-parentheses.c:19:16: warning: \'&\' within \'|\' [-Wbitwise-op-parentheses]","clang/test/Sema/bitwise-op-parentheses.c:27:12: warning: \'^\' within \'|\' [-Wbitwise-op-parentheses]","clang/test/Sema/bitwise-op-parentheses.c:35:16: warning: \'^\' within \'|\' [-Wbitwise-op-parentheses]","clang/test/Sema/bitwise-op-parentheses.c:43:12: warning: \'&\' within \'^\' [-Wbitwise-op-parentheses]","clang/test/Sema/bitwise-op-parentheses.c:51:16: warning: \'&\' within \'^\' [-Wbitwise-op-parentheses]"}
}
},
["warn_block_capture_autoreleasing"]={
[j]={"block-capture-autoreleasing"},
[k]="block-capture-autoreleasing",
[g]="warn_block_capture_autoreleasing",
[b]="block captures an autoreleasing out-parameter, which may result in use-after-free bugs",
[c]="block captures an autoreleasing out-parameter, which may result in use-after-free bugs",
[d]=m,
[e]="block captures an autoreleasing out\\-parameter, which may result in use\\-after\\-free bugs",
[f]=" \\[(?:\\-Werror,)?\\-Wblock\\-capture\\-autoreleasing[^\\]]*\\]",
[h]=oc,
[a]={"c81708e6ecf0",1477345554,"[Sema][ObjC] Warn about implicitly autoreleasing out-parameters captured","[Sema][ObjC] Warn about implicitly autoreleasing out-parameters captured\nby blocks.\n\nAdd a new warning \"-Wblock-capture-autoreleasing\". The warning warns\nabout implicitly autoreleasing out-parameters captured by blocks which\ncan introduce use-after-free bugs that are hard to debug.\n\nrdar://problem/15377548\n\nDifferential Revision: https://reviews.llvm.org/D25844\n\nllvm-svn: 285031"},
[i]={{G,19261,"// Returns true if the capture by block was successful.\nstatic bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid) {\n // ...\n // Warn about implicitly autoreleasing indirect parameters captured by blocks.\n if (const auto *PT = CaptureType->getAs<PointerType>()) {\n // ...\n if (!Invalid && PointeeTy->getAs<ObjCObjectPointerType>() && PointeeTy.getObjCLifetime() == Qualifiers::OCL_Autoreleasing && !S.Context.hasDirectOwnershipQualifier(PointeeTy)) {\n if (BuildAndDiagnose) {\n // ...\n S.Diag(Loc, diag::warn_block_capture_autoreleasing);"}},
[l]={
["clang/test/SemaObjC/arc.m"]={"clang/test/SemaObjC/arc.m:829:12: warning: block captures an autoreleasing out-parameter, which may result in use-after-free bugs [-Wblock-capture-autoreleasing]","clang/test/SemaObjC/arc.m:830:12: warning: block captures an autoreleasing out-parameter, which may result in use-after-free bugs [-Wblock-capture-autoreleasing]","clang/test/SemaObjC/arc.m:832:12: warning: block captures an autoreleasing out-parameter, which may result in use-after-free bugs [-Wblock-capture-autoreleasing]","clang/test/SemaObjC/arc.m:835:12: warning: block captures an autoreleasing out-parameter, which may result in use-after-free bugs [-Wblock-capture-autoreleasing]","clang/test/SemaObjC/arc.m:836:12: warning: block captures an autoreleasing out-parameter, which may result in use-after-free bugs [-Wblock-capture-autoreleasing]","clang/test/SemaObjC/arc.m:838:12: warning: block captures an autoreleasing out-parameter, which may result in use-after-free bugs [-Wblock-capture-autoreleasing]"}
}
},
["warn_block_literal_attributes_on_omitted_return_type"]={
[j]={x,q},
[k]=q,
[g]="warn_block_literal_attributes_on_omitted_return_type",
[b]="attribute %0 ignored, because it cannot be applied to omitted return type",
[c]="attribute A ignored, because it cannot be applied to omitted return type",
[d]=m,
[e]="attribute (.*?) ignored, because it cannot be applied to omitted return type",
[f]=y,
[h]=O,
[a]={"99d133482f7c",1461004851,"Block: Fix a crash when we have type attributes or qualifiers with omitted","Block: Fix a crash when we have type attributes or qualifiers with omitted\nreturn type.\n\nEmit a warning instead of crashing in IR generation.\n\nrdar://22762981\n\nDifferential Revision: http://reviews.llvm.org/D18567\n\nllvm-svn: 266648"},
[i]={{lb,817,"/// Return true if this is omitted block return type. Also check type\n/// attributes and type qualifiers when returning true.\nstatic bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result) {\n // ...\n for (ParsedAttr &AL : declarator.getMutableDeclSpec().getAttributes()) {\n // ...\n S.Diag(AL.getLoc(), diag::warn_block_literal_attributes_on_omitted_return_type) << AL;"}},
[l]={
["clang/test/SemaObjC/block-omitted-return-type.m"]={"clang/test/SemaObjC/block-omitted-return-type.m:13:33: warning: attribute \'_Nonnull\' ignored, because it cannot be applied to omitted return type [-Wignored-attributes]","clang/test/SemaObjC/block-omitted-return-type.m:19:34: warning: attribute \'_Nonnull\' ignored, because it cannot be applied to omitted return type [-Wignored-attributes]","clang/test/SemaObjC/block-omitted-return-type.m:32:34: warning: attribute \'_Nonnull\' ignored, because it cannot be applied to omitted return type [-Wignored-attributes]","clang/test/SemaObjC/block-omitted-return-type.m:32:77: warning: attribute \'_Nullable\' ignored, because it cannot be applied to omitted return type [-Wignored-attributes]","clang/test/SemaObjC/block-omitted-return-type.m:38:69: warning: attribute \'_Nonnull\' ignored, because it cannot be applied to omitted return type [-Wignored-attributes]"}
}
},
["warn_block_literal_qualifiers_on_omitted_return_type"]={
[j]={r,P,Nc,"ignored-qualifiers"},
[k]="ignored-qualifiers",
[g]="warn_block_literal_qualifiers_on_omitted_return_type",
[b]="\'%0\' qualifier on omitted return type %1 has no effect",
[c]="\'A\' qualifier on omitted return type B has no effect",
[d]=m,
[e]="\'(.*?)\' qualifier on omitted return type (.*?) has no effect",
[f]=" \\[(?:\\-Werror,)?\\-Wignored\\-qualifiers[^\\]]*\\]",
[h]=O,
[a]={"99d133482f7c",1461004851,"Block: Fix a crash when we have type attributes or qualifiers with omitted","Block: Fix a crash when we have type attributes or qualifiers with omitted\nreturn type.\n\nEmit a warning instead of crashing in IR generation.\n\nrdar://22762981\n\nDifferential Revision: http://reviews.llvm.org/D18567\n\nllvm-svn: 266648"},
[i]={{lb,829,"/// Return true if this is omitted block return type. Also check type\n/// attributes and type qualifiers when returning true.\nstatic bool checkOmittedBlockReturnType(Sema &S, Declarator &declarator, QualType Result) {\n // ...\n diagnoseAndRemoveTypeQualifiers(S, DS, TypeQuals, Result, (unsigned)-1, diag::warn_block_literal_qualifiers_on_omitted_return_type);"}},
[l]={
["clang/test/SemaObjC/block-omitted-return-type.m"]={"clang/test/SemaObjC/block-omitted-return-type.m:23:34: warning: \'const\' qualifier on omitted return type \'<dependent type>\' has no effect [-Wignored-qualifiers]","clang/test/SemaObjC/block-omitted-return-type.m:29:34: warning: \'const\' qualifier on omitted return type \'<dependent type>\' has no effect [-Wignored-qualifiers]","clang/test/SemaObjC/block-omitted-return-type.m:32:87: warning: \'const\' qualifier on omitted return type \'<dependent type>\' has no effect [-Wignored-qualifiers]","clang/test/SemaObjC/block-omitted-return-type.m:38:78: warning: \'const\' qualifier on omitted return type \'<dependent type>\' has no effect [-Wignored-qualifiers]"}
}
},
["warn_bool_switch_condition"]={
[j]={P,T,"switch-bool"},
[k]="switch-bool",
[g]="warn_bool_switch_condition",
[b]="switch condition has boolean value",
[c]="switch condition has boolean value",
[d]=m,
[e]="switch condition has boolean value",
[f]=" \\[(?:\\-Werror,)?\\-Wswitch\\-bool[^\\]]*\\]",
[h]=n,
[a]={"93135aad2926",1255807974,"Fix for PR5190, Credit to Zhanyong Wan.","Fix for PR5190, Credit to Zhanyong Wan.\n\nllvm-svn: 84346"},
[i]={{X,1111,"StmtResult Sema::ActOnStartOfSwitchStmt(SourceLocation SwitchLoc, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc) {\n // ...\n if (CondExpr && !CondExpr->isTypeDependent()) {\n // ...\n if (CondExpr->isKnownToHaveBooleanValue()) {\n // ...\n Diag(SwitchLoc, diag::warn_bool_switch_condition) << CondExpr->getSourceRange();"}},
[l]={
["clang/test/Parser/decomposed-condition.cpp"]={"clang/test/Parser/decomposed-condition.cpp:81:3: warning: switch condition has boolean value [-Wswitch-bool]"}
}
},
["warn_braces_around_init"]={
[j]={"braced-scalar-init"},
[k]="braced-scalar-init",
[g]={{nil,t,"warn_braces_around_init"}},
[b]={{nil,t,"braces around %select{scalar |}0initializer"}},
[c]={{nil,t,{"braces around ",{"scalar ",r},"initializer"}}},
[d]=m,
[e]="braces around (?:scalar |)initializer",
[f]=" \\[(?:\\-Werror,)?\\-Wbraced\\-scalar\\-init[^\\]]*\\]",
[h]={{nil,t,n}},
[a]={"931fcd3ba011",1576908663,"[WebAssembly] Improve clang diagnostics for wasm attributes","[WebAssembly] Improve clang diagnostics for wasm attributes\n\nThis patch addresses the review comments on r352930:\n\n - Removes redundant diagnostic checking code\n - Removes errnoneous use of diag::err_alias_is_definition, which\n turned out to be ineffective anyway since functions can be defined later\n in the translation unit and avoid detection.\n - Adds a test for various invalid cases for import_name and import_module.\n\nDifferential Revision: https://reviews.llvm.org/D59520"},
[i]={{Rb,1191,"/// Warn that \\p Entity was of scalar type and was initialized by a\n/// single-element braced initializer list.\nstatic void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity, SourceRange Braces) {\n // ...\n case InitializedEntity::EK_VectorElement:\n case InitializedEntity::EK_ComplexElement:\n case InitializedEntity::EK_ArrayElement:\n case InitializedEntity::EK_Parameter:\n case InitializedEntity::EK_Parameter_CF_Audited:\n case InitializedEntity::EK_TemplateParameter:\n case InitializedEntity::EK_Result:\n case InitializedEntity::EK_ParenAggInitMember:\n // ...\n DiagID = diag::warn_braces_around_init;"},{Rb,1198,"/// Warn that \\p Entity was of scalar type and was initialized by a\n/// single-element braced initializer list.\nstatic void warnBracedScalarInit(Sema &S, const InitializedEntity &Entity, SourceRange Braces) {\n // ...\n case InitializedEntity::EK_Member:\n // Warn on aggregate initialization but not on ctor init list or\n // default member initializer.\n if (Entity.getParent())\n DiagID = diag::warn_braces_around_init;"}},
[l]={
["clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp"]={"clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp:61:7: warning: braces around scalar initializer [-Wbraced-scalar-init]","clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp:62:7: warning: braces around scalar initializer [-Wbraced-scalar-init]","clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp:62:12: warning: braces around scalar initializer [-Wbraced-scalar-init]","clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp:63:10: warning: braces around scalar initializer [-Wbraced-scalar-init]","clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp:64:10: warning: braces around scalar initializer [-Wbraced-scalar-init]"}
}
},
["warn_break_binds_to_switch"]={
[j]={kc},
[k]=kc,
[g]="warn_break_binds_to_switch",
[b]="\'break\' is bound to loop, GCC binds it to switch",
[c]="\'break\' is bound to loop, GCC binds it to switch",
[d]=m,
[e]="\'break\' is bound to loop, GCC binds it to switch",
[f]=" \\[(?:\\-Werror,)?\\-Wgcc\\-compat[^\\]]*\\]",
[h]=n,
[a]={"09f9924acf1a",1390489500,"Fix to PR8880 (clang dies processing a for loop)","Fix to PR8880 (clang dies processing a for loop)\n\nDue to statement expressions supported as GCC extension, it is possible\nto put \'break\' or \'continue\' into a loop/switch statement but outside\nits body, for example:\n\n for ( ; ({ if (first) { first = 0; continue; } 0; }); )\n\nThis code is rejected by GCC if compiled in C mode but is accepted in C++\ncode. GCC bug 44715 tracks this discrepancy. Clang used code generation\nthat differs from GCC in both modes: only statement of the third\nexpression of \'for\' behaves as if it was inside loop body.\n\nThis change makes code generation more close to GCC, considering \'break\'\nor \'continue\' statement in condition and increment expressions of a\nloop as it was inside the loop body. It also adds error for the cases\nwhen \'break\'/\'continue\' appear outside loop due to this syntax. If\ncode generation differ from GCC, warning is issued.\n\nDifferential Revision: http://llvm-reviews.chandlerc.com/D2518\n\nllvm-svn: 199897"},
[i]={{X,2121,"void Sema::CheckBreakContinueBinding(Expr *E) {\n // ...\n if (BCFinder.BreakFound() && BreakParent) {\n if (BreakParent->getFlags() & Scope::SwitchScope) {\n Diag(BCFinder.GetBreakLoc(), diag::warn_break_binds_to_switch);"}},
[l]={
["clang/test/Sema/loop-control.c"]={"clang/test/Sema/loop-control.c:98:20: warning: \'break\' is bound to loop, GCC binds it to switch [-Wgcc-compat]","clang/test/Sema/loop-control.c:105:26: warning: \'break\' is bound to loop, GCC binds it to switch [-Wgcc-compat]","clang/test/Sema/loop-control.c:112:29: warning: \'break\' is bound to loop, GCC binds it to switch [-Wgcc-compat]","clang/test/Sema/loop-control.c:119:21: warning: \'break\' is bound to loop, GCC binds it to switch [-Wgcc-compat]","clang/test/Sema/loop-control.c:146:29: warning: \'break\' is bound to loop, GCC binds it to switch [-Wgcc-compat]"}
}
},
["warn_builtin_chk_overflow"]={
[j]={"builtin-memcpy-chk-size"},
[k]="builtin-memcpy-chk-size",
[g]={{nil,B,"warn_builtin_chk_overflow"}},
[b]={{nil,B,"\'%0\' will always overflow; destination buffer has size %1, but size argument is %2"}},
[c]={{nil,B,"\'A\' will always overflow; destination buffer has size B, but size argument is C"}},
[d]=m,
[e]="\'(.*?)\' will always overflow; destination buffer has size (.*?), but size argument is (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wbuiltin\\-memcpy\\-chk\\-size[^\\]]*\\]",
[h]={{nil,B,n}},
[a]={"b6e16ea006a2",1552937025,"[Sema] Add some compile time _FORTIFY_SOURCE diagnostics","[Sema] Add some compile time _FORTIFY_SOURCE diagnostics\n\nThese diagnose overflowing calls to subset of fortifiable functions. Some\nfunctions, like sprintf or strcpy aren\'t supported right not, but we should\nprobably support these in the future. We previously supported this kind of\nfunctionality with -Wbuiltin-memcpy-chk-size, but that diagnostic doesn\'t work\nwith _FORTIFY implementations that use wrapper functions. Also unlike that\ndiagnostic, we emit these warnings regardless of whether _FORTIFY_SOURCE is\nactually enabled, which is nice for programs that don\'t enable the runtime\nchecks.\n\nWhy not just use diagnose_if, like Bionic does? We can get better diagnostics in\nthe compiler (i.e. mention the sizes), and we have the potential to diagnose\nsprintf and strcpy which is impossible with diagnose_if (at least, in languages\nthat don\'t support C++14 constexpr). This approach also saves standard libraries\nfrom having to add diagnose_if.\n\nrdar://48006655\n\nDifferential revision: https://reviews.llvm.org/D58797\n\nllvm-svn: 356397"},
[i]={{u,1276,"void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall) {\n // ...\n case Builtin::BI__builtin___memcpy_chk:\n case Builtin::BI__builtin___memmove_chk:\n case Builtin::BI__builtin___memset_chk:\n case Builtin::BI__builtin___strlcat_chk:\n case Builtin::BI__builtin___strlcpy_chk:\n case Builtin::BI__builtin___strncat_chk:\n case Builtin::BI__builtin___strncpy_chk:\n case Builtin::BI__builtin___stpncpy_chk:\n case Builtin::BI__builtin___memccpy_chk:\n case Builtin::BI__builtin___mempcpy_chk: {\n DiagID = diag::warn_builtin_chk_overflow;"},{u,1286,"void Sema::checkFortifiedBuiltinMemoryFunction(FunctionDecl *FD, CallExpr *TheCall) {\n // ...\n case Builtin::BI__builtin___snprintf_chk:\n case Builtin::BI__builtin___vsnprintf_chk: {\n DiagID = diag::warn_builtin_chk_overflow;"}},
[l]={
["clang/test/Sema/builtins.c"]={"clang/test/Sema/builtins.c:231:9: warning: \'strlcpy\' will always overflow; destination buffer has size 20, but size argument is 40 [-Wbuiltin-memcpy-chk-size]","clang/test/Sema/builtins.c:238:9: warning: \'strlcat\' will always overflow; destination buffer has size 20, but size argument is 40 [-Wbuiltin-memcpy-chk-size]","clang/test/Sema/builtins.c:248:5: warning: \'memcpy\' will always overflow; destination buffer has size 4, but size argument is 5 [-Wbuiltin-memcpy-chk-size]","clang/test/Sema/builtins.c:256:5: warning: \'memcpy\' will always overflow; destination buffer has size 4, but size argument is 5 [-Wbuiltin-memcpy-chk-size]","clang/test/Sema/builtins.c:354:3: warning: \'memcpy\' will always overflow; destination buffer has size 10, but size argument is 11 [-Wbuiltin-memcpy-chk-size]","clang/test/Sema/builtins.c:355:3: warning: \'memcpy\' will always overflow; destination buffer has size 10, but size argument is 11 [-Wbuiltin-memcpy-chk-size]"}
}
},
["warn_builtin_unknown"]={
[j]={P,T,"implicit","implicit-function-declaration",cb},
[k]="implicit-function-declaration",
[g]="warn_builtin_unknown",
[b]="use of unknown builtin %0",
[c]="use of unknown builtin A",
[d]=zc,
[e]="use of unknown builtin (.*?)",
[f]=" \\[[^\\]]*\\-Wimplicit\\-function\\-declaration[^\\]]*\\]",
[h]=n,
[a]={"56fbc37bbba3",1254172459,"Provide a custom diagnostic when code tries to use an unknown builtin","Provide a custom diagnostic when code tries to use an unknown builtin\n\nllvm-svn: 83014"},
[i]={{H,16050,"/// ImplicitlyDefineFunction - An undeclared identifier was used in a function\n/// call, forming a call to an implicitly defined function (per C99 6.5.1p2).\nNamedDecl *Sema::ImplicitlyDefineFunction(SourceLocation Loc, IdentifierInfo &II, Scope *S) {\n // ...\n if (II.getName().startswith(\"__builtin_\"))\n diag_id = diag::warn_builtin_unknown;"}},
[l]={
["clang/test/Sema/builtins-x86_64.c"]={"clang/test/Sema/builtins-x86_64.c:17:9: error: use of unknown builtin \'__builtin_ia32_readeflags_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:18:9: error: use of unknown builtin \'__builtin_ia32_writeeflags_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:19:9: error: use of unknown builtin \'__builtin_ia32_cvtss2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:20:9: error: use of unknown builtin \'__builtin_ia32_cvttss2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:21:9: error: use of unknown builtin \'__builtin_ia32_cvtsd2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:22:9: error: use of unknown builtin \'__builtin_ia32_cvttsd2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:23:9: error: use of unknown builtin \'__builtin_ia32_crc32di\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:24:9: error: use of unknown builtin \'__builtin_ia32_rdfsbase64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:25:9: error: use of unknown builtin \'__builtin_ia32_rdgsbase64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:26:9: error: use of unknown builtin \'__builtin_ia32_wrfsbase64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:27:9: error: use of unknown builtin \'__builtin_ia32_wrgsbase64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:28:9: error: use of unknown builtin \'__builtin_ia32_fxrstor64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:29:9: error: use of unknown builtin \'__builtin_ia32_fxsave64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:30:9: error: use of unknown builtin \'__builtin_ia32_xsave64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:31:9: error: use of unknown builtin \'__builtin_ia32_xrstor64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:32:9: error: use of unknown builtin \'__builtin_ia32_xsaveopt64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:33:9: error: use of unknown builtin \'__builtin_ia32_xrstors64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:34:9: error: use of unknown builtin \'__builtin_ia32_xsavec64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:35:9: error: use of unknown builtin \'__builtin_ia32_xsaves64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:36:9: error: use of unknown builtin \'__builtin_ia32_addcarryx_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:37:9: error: use of unknown builtin \'__builtin_ia32_addcarry_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:38:9: error: use of unknown builtin \'__builtin_ia32_subborrow_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:39:9: error: use of unknown builtin \'__builtin_ia32_rdseed64_step\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:40:9: error: use of unknown builtin \'__builtin_ia32_bextr_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:41:9: error: use of unknown builtin \'__builtin_ia32_bzhi_di\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:42:9: error: use of unknown builtin \'__builtin_ia32_pdep_di\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:43:9: error: use of unknown builtin \'__builtin_ia32_pext_di\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:44:9: error: use of unknown builtin \'__builtin_ia32_bextri_u64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:45:9: error: use of unknown builtin \'__builtin_ia32_pbroadcastq512_gpr_mask\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:46:9: error: use of unknown builtin \'__builtin_ia32_pbroadcastq128_gpr_mask\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:47:9: error: use of unknown builtin \'__builtin_ia32_pbroadcastq256_gpr_mask\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:48:9: error: use of unknown builtin \'__builtin_ia32_vcvtsd2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:49:9: error: use of unknown builtin \'__builtin_ia32_vcvtsd2usi64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:50:9: error: use of unknown builtin \'__builtin_ia32_vcvtss2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:51:9: error: use of unknown builtin \'__builtin_ia32_vcvtss2usi64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:52:9: error: use of unknown builtin \'__builtin_ia32_vcvttsd2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:53:9: error: use of unknown builtin \'__builtin_ia32_vcvttsd2usi64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:54:9: error: use of unknown builtin \'__builtin_ia32_vcvttss2si64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:55:9: error: use of unknown builtin \'__builtin_ia32_vcvttss2usi64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:56:9: error: use of unknown builtin \'__builtin_ia32_cvtsi2sd64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:57:9: error: use of unknown builtin \'__builtin_ia32_cvtsi2ss64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:58:9: error: use of unknown builtin \'__builtin_ia32_cvtusi2sd64\' [-Wimplicit-function-declaration]","clang/test/Sema/builtins-x86_64.c:59:9: error: use of unknown builtin \'__builtin_ia32_cvtusi2ss64\' [-Wimplicit-function-declaration]"}
}
},
["warn_c17_compat_ellipsis_only_parameter"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,v,"warn_c17_compat_ellipsis_only_parameter"}},
[b]={{nil,v,"\'...\' as the only parameter of a function is incompatible with C standards before C2x"}},
[c]={{nil,v,"\'...\' as the only parameter of a function is incompatible with C standards before C2x"}},
[d]=m,
[e]="\'\\.\\.\\.\' as the only parameter of a function is incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,v,n}},
[a]={sb,1625925174,rb,vb},
[i]={{lb,5445,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n // ...\n for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n // ...\n case DeclaratorChunk::Function: {\n // ...\n // OpenCL disallows functions without a prototype, but it doesn\'t enforce\n // strict prototypes as in C2x because it allows a function definition to\n // have an identifier list. See OpenCL 3.0 6.11/g for more details.\n if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.requiresStrictPrototypes() && !LangOpts.OpenCL) {\n // ...\n } else {\n // We allow a zero-parameter variadic function in C if the\n // function is marked with the \"overloadable\" attribute. Scan\n // for this attribute now. We also allow it in C2x per WG14 N2975.\n if (!FTI.NumParams && FTI.isVariadic && !LangOpts.CPlusPlus) {\n if (LangOpts.C2x)\n S.Diag(FTI.getEllipsisLoc(), diag::warn_c17_compat_ellipsis_only_parameter);"}},
[l]={
["clang/test/C/C2x/n2975.c"]={"clang/test/C/C2x/n2975.c:11:11: warning: \'...\' as the only parameter of a function is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2975.c:35:20: warning: \'...\' as the only parameter of a function is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c17_compat_static_assert_no_message"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,w,"warn_c17_compat_static_assert_no_message"}},
[b]={{nil,w,"\'_Static_assert\' with no message is incompatible with C standards before C2x"}},
[c]={{nil,w,"\'_Static_assert\' with no message is incompatible with C standards before C2x"}},
[d]=m,
[e]="\'_Static_assert\' with no message is incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,w,db}},
[a]={"69350e569dc4",1612659633,"[C++20][Modules][3/8] Initial handling for module partitions.","[C++20][Modules][3/8] Initial handling for module partitions.\n\nThis implements the parsing and recognition of module partition CMIs\nand removes the FIXMEs in the parser.\n\nModule partitions are recognised in the base computation of visibility,\nhowever additional amendments to visibility follow in subsequent patches.\n\nDifferential Revision: https://reviews.llvm.org/D118586"},
[i]={{"clang/lib/Parse/ParseDeclCXX.cpp",1009,"/// ParseStaticAssertDeclaration - Parse C++0x or C11 static_assert-declaration.\n///\n/// [C++0x] static_assert-declaration:\n/// static_assert ( constant-expression , string-literal ) ;\n///\n/// [C11] static_assert-declaration:\n/// _Static_assert ( constant-expression , string-literal ) ;\n///\nDecl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd) {\n // ...\n if (Tok.is(tok::r_paren)) {\n // ...\n if (getLangOpts().CPlusPlus17)\n // ...\n else if (getLangOpts().CPlusPlus)\n // ...\n else if (getLangOpts().C2x)\n DiagVal = diag::warn_c17_compat_static_assert_no_message;"}},
[l]={
["clang/test/Parser/static_assert.c"]={"clang/test/Parser/static_assert.c:39:17: warning: \'_Static_assert\' with no message is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_bitint_suffix"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,D,"warn_c2x_compat_bitint_suffix"}},
[b]={{nil,D,"\'_BitInt\' suffix for literals is incompatible with C standards before C2x"}},
[c]={{nil,D,"\'_BitInt\' suffix for literals is incompatible with C standards before C2x"}},
[d]=m,
[e]="\'_BitInt\' suffix for literals is incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,D,O}},
[a]={"8cba72177dcd",1647264157,"Implement literal suffixes for _BitInt","Implement literal suffixes for _BitInt\n\nWG14 adopted N2775 (http://www.open-std.org/jtc1/sc22/wg14/www/docs/n2775.pdf)\nat our Feb 2022 meeting. This paper adds a literal suffix for\nbit-precise types that automatically sizes the bit-precise type to be\nthe smallest possible legal _BitInt type that can represent the literal\nvalue. The suffix chosen is wb (for a signed bit-precise type) which\ncan be combined with the u suffix (for an unsigned bit-precise type).\n\nThe preprocessor continues to operate as-if all integer types were\nintmax_t/uintmax_t, including bit-precise integer types. It is a\nconstraint violation if the bit-precise literal is too large to fit\nwithin that type in the context of the preprocessor (when still using\na pp-number preprocessing token), but it is not a constraint violation\nin other circumstances. This allows you to make bit-precise integer\nliterals that are wider than what the preprocessor currently supports\nin order to initialize variables, etc."},
[i]={{"clang/lib/Lex/PPExpressions.cpp",340,"/// EvaluateValue - Evaluate the token PeekTok (and any others needed) and\n/// return the computed value in Result. Return true if there was an error\n/// parsing. This function also returns information about the form of the\n/// expression in DT. See above for information on what DT means.\n///\n/// If ValueLive is false, then this value is being evaluated in a context where\n/// the result is not used. As such, avoid diagnostics that relate to\n/// evaluation.\nstatic bool EvaluateValue(PPValue &Result, Token &PeekTok, DefinedTracker &DT, bool ValueLive, Preprocessor &PP) {\n // ...\n case tok::numeric_constant: {\n // ...\n // \'wb/uwb\' literals are a C2x feature. We explicitly do not support the\n // suffix in C++ as an extension because a library-based UDL that resolves\n // to a library type may be more appropriate there.\n if (Literal.isBitInt)\n PP.Diag(PeekTok, PP.getLangOpts().C2x ? diag::warn_c2x_compat_bitint_suffix : diag::ext_c2x_bitint_suffix);"},{G,4068,"ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {\n // ...\n if (Literal.isFixedPointLiteral()) {\n // ...\n } else if (Literal.isFloatingLiteral()) {\n // ...\n } else if (!Literal.isIntegerLiteral()) {\n // ...\n } else {\n // ...\n // \'wb/uwb\' literals are a C2x feature. We support _BitInt as a type in C++,\n // but we do not currently support the suffix in C++ mode because it\'s not\n // entirely clear whether WG21 will prefer this suffix to return a library\n // type such as std::bit_int instead of returning a _BitInt.\n if (Literal.isBitInt && !getLangOpts().CPlusPlus)\n PP.Diag(Tok.getLocation(), getLangOpts().C2x ? diag::warn_c2x_compat_bitint_suffix : diag::ext_c2x_bitint_suffix);"}},
[l]={
["clang/test/Lexer/bitint-constants-compat.c"]={"clang/test/Lexer/bitint-constants-compat.c:5:5: warning: \'_BitInt\' suffix for literals is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/Lexer/bitint-constants-compat.c:11:3: warning: \'_BitInt\' suffix for literals is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_digit_separator"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,w,"warn_c2x_compat_digit_separator"}},
[b]={{nil,w,"digit separators are incompatible with C standards before C2x"}},
[c]={{nil,w,"digit separators are incompatible with C standards before C2x"}},
[d]=m,
[e]="digit separators are incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,w,A}},
[a]={"e44831005905",1615551663,"Add support for digit separators in C2x.","Add support for digit separators in C2x.\n\nWG14 adopted N2626 at the meetings this week. This commit adds support\nfor using \' as a digit separator in a numeric literal which is\ncompatible with the C++ feature."},
[i]={{bb,1963,"/// LexNumericConstant - Lex the remainder of a integer or floating point\n/// constant. From[-1] is the first character lexed. Return the end of the\n/// constant.\nbool Lexer::LexNumericConstant(Token &Result, const char *CurPtr) {\n // ...\n // If we have a digit separator, continue.\n if (C == \'\\\'\' && (LangOpts.CPlusPlus14 || LangOpts.C2x)) {\n // ...\n if (isAsciiIdentifierContinue(Next)) {\n if (!isLexingRawMode())\n Diag(CurPtr, LangOpts.CPlusPlus ? diag::warn_cxx11_compat_digit_separator : diag::warn_c2x_compat_digit_separator);"}},
[l]={
["clang/test/Sema/pre-c2x-compat.c"]={"clang/test/Sema/pre-c2x-compat.c:3:21: warning: digit separators are incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_empty_initializer"]={
[j]={Q,nb},
[k]=Q,
[g]="warn_c2x_compat_empty_initializer",
[b]="use of an empty initializer is incompatible with C standards before C2x",
[c]="use of an empty initializer is incompatible with C standards before C2x",
[d]=m,
[e]="use of an empty initializer is incompatible with C standards before C2x",
[f]=ob,
[h]=db,
[a]={"5d8aaad4452f",1680549555,"[C2x] Implement support for empty brace initialization (WG14 N2900 and WG14 N3011)","[C2x] Implement support for empty brace initialization (WG14 N2900 and WG14 N3011)\n\nThis implements support for allowing {} to consistently zero initialize\nobjects. We already supported most of this work as a GNU extension, but\nthe C2x feature goes beyond what the GNU extension allowed.\n\nThe changes in this patch are:\n\n* Removed the -Wgnu-empty-initializer warning group. The extension is\n now a C2x extension warning instead. Note that use of\n `-Wno-gnu-empty-initializer seems` to be quite low in the wild\n(https://sourcegraph.com/search?q=context%3Aglobal+-file%3A.*test.*+%22-Wno-gnu-empty-initializer%22&patternType=standard&sm=1&groupBy=repo\n which currently only gives 8 hits total), so this is not expected to\n be an overly disruptive change. But I\'m adding the clang vendors\n review group just in case this expectation is wrong.\n* Reworded the diagnostic wording to be about a C2x extension, added a\n pre-C2x compat warning.\n* Allow {} to zero initialize a VLA\n\nThis functionality is exposed as an extension in all older C modes\n(same as the GNU extension was), but does *not* allow the extension for\nVLA initialization in C++ due to concern about handling non-trivially\nconstructible types.\n\nDifferential Revision: https://reviews.llvm.org/D147349"},
[i]={{"clang/lib/Parse/ParseInit.cpp",456,"/// ParseBraceInitializer - Called when parsing an initializer that has a\n/// leading open brace.\n///\n/// initializer: [C99 6.7.8]\n/// \'{\' initializer-list \'}\'\n/// \'{\' initializer-list \',\' \'}\'\n/// [C2x] \'{\' \'}\'\n///\n/// initializer-list:\n/// designation[opt] initializer ...[opt]\n/// initializer-list \',\' designation[opt] initializer ...[opt]\n///\nExprResult Parser::ParseBraceInitializer() {\n // ...\n if (Tok.is(tok::r_brace)) {\n // Empty initializers are a C++ feature and a GNU extension to C before C2x.\n if (!getLangOpts().CPlusPlus) {\n Diag(LBraceLoc, getLangOpts().C2x ? diag::warn_c2x_compat_empty_initializer : diag::ext_c_empty_initializer);"}},
[l]={
["clang/test/C/C2x/n2900_n3011.c"]={"clang/test/C/C2x/n2900_n3011.c:12:30: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:14:11: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:16:16: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:25:24: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:28:16: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:30:39: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:36:15: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:41:10: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:47:10: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:49:5: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2900_n3011.c:56:23: warning: use of an empty initializer is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_keyword"]={
[j]={Q,nb},
[k]=Q,
[g]="warn_c2x_compat_keyword",
[b]="\'%0\' is incompatible with C standards before C2x",
[c]="\'A\' is incompatible with C standards before C2x",
[d]=m,
[e]="\'(.*?)\' is incompatible with C standards before C2x",
[f]=ob,
[h]=db,
[a]={"06174134e418",1677335266,"[C2x] Implement support for revised spelling of keywords","[C2x] Implement support for revised spelling of keywords\n\nThis implements WG14 N2934\n(https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2934.pdf), which\nadds keywords for alignas, alignof, bool, static_assert, and\nthread_local in C, as aliases for _Alignas, _Alignof, _Bool,\n_Static_assert, and _Thread_local. We already supported the keywords in\nC2x mode, but this completes support by adding pre-C2x compat warnings\nand updates the stdalign.h header in freestanding mode."},
[i]={{Tb,4001,"/// ParseDeclarationSpecifiers\n/// declaration-specifiers: [C99 6.7]\n/// storage-class-specifier declaration-specifiers[opt]\n/// type-specifier declaration-specifiers[opt]\n/// [C99] function-specifier declaration-specifiers[opt]\n/// [C11] alignment-specifier declaration-specifiers[opt]\n/// [GNU] attributes declaration-specifiers[opt]\n/// [Clang] \'__module_private__\' declaration-specifiers[opt]\n/// [ObjC1] \'__kindof\' declaration-specifiers[opt]\n///\n/// storage-class-specifier: [C99 6.7.1]\n/// \'typedef\'\n/// \'extern\'\n/// \'static\'\n/// \'auto\'\n/// \'register\'\n/// [C++] \'mutable\'\n/// [C++11] \'thread_local\'\n/// [C11] \'_Thread_local\'\n/// [GNU] \'__thread\'\n/// function-specifier: [C99 6.7.4]\n/// [C99] \'inline\'\n/// [C++] \'virtual\'\n/// [C++] \'explicit\'\n/// [OpenCL] \'__kernel\'\n/// \'friend\': [C++ dcl.friend]\n/// \'constexpr\': [C++0x dcl.constexpr]\nvoid Parser::ParseDeclarationSpecifiers(DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSContext, LateParsedAttrList *LateAttrs, ImplicitTypenameContext AllowImplicitTypename) {\n // ...\n while (true) {\n // ...\n case tok::kw_thread_local:\n if (getLangOpts().C2x)\n Diag(Tok, diag::warn_c2x_compat_keyword) << Tok.getName();"},{Tb,4245,"/// ParseDeclarationSpecifiers\n/// declaration-specifiers: [C99 6.7]\n/// storage-class-specifier declaration-specifiers[opt]\n/// type-specifier declaration-specifiers[opt]\n/// [C99] function-specifier declaration-specifiers[opt]\n/// [C11] alignment-specifier declaration-specifiers[opt]\n/// [GNU] attributes declaration-specifiers[opt]\n/// [Clang] \'__module_private__\' declaration-specifiers[opt]\n/// [ObjC1] \'__kindof\' declaration-specifiers[opt]\n///\n/// storage-class-specifier: [C99 6.7.1]\n/// \'typedef\'\n/// \'extern\'\n/// \'static\'\n/// \'auto\'\n/// \'register\'\n/// [C++] \'mutable\'\n/// [C++11] \'thread_local\'\n/// [C11] \'_Thread_local\'\n/// [GNU] \'__thread\'\n/// function-specifier: [C99 6.7.4]\n/// [C99] \'inline\'\n/// [C++] \'virtual\'\n/// [C++] \'explicit\'\n/// [OpenCL] \'__kernel\'\n/// \'friend\': [C++ dcl.friend]\n/// \'constexpr\': [C++0x dcl.constexpr]\nvoid Parser::ParseDeclarationSpecifiers(DeclSpec &DS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSContext, LateParsedAttrList *LateAttrs, ImplicitTypenameContext AllowImplicitTypename) {\n // ...\n while (true) {\n // ...\n case tok::kw_bool:\n if (getLangOpts().C2x)\n Diag(Tok, diag::warn_c2x_compat_keyword) << Tok.getName();"},{Tb,7760,"/// [GNU] typeof-specifier:\n/// typeof ( expressions )\n/// typeof ( type-name )\n/// [GNU/C++] typeof unary-expression\n/// [C2x] typeof-specifier:\n/// typeof \'(\' typeof-specifier-argument \')\'\n/// typeof_unqual \'(\' typeof-specifier-argument \')\'\n///\n/// typeof-specifier-argument:\n/// expression\n/// type-name\n///\nvoid Parser::ParseTypeofSpecifier(DeclSpec &DS) {\n // ...\n if (getLangOpts().C2x && !II->getName().startswith(\"__\"))\n Diag(Tok.getLocation(), diag::warn_c2x_compat_keyword) << Tok.getName();"},{Tb,7960,"void Parser::DiagnoseBitIntUse(const Token &Tok) {\n // ...\n if (Tok.is(tok::kw__ExtInt)) {\n // ...\n } else {\n // In C2x mode, diagnose that the use is not compatible with pre-C2x modes.\n // Otherwise, diagnose that the use is a Clang extension.\n if (getLangOpts().C2x)\n Diag(Loc, diag::warn_c2x_compat_keyword) << Tok.getName();"},{"clang/lib/Parse/ParseDeclCXX.cpp",976,"/// ParseStaticAssertDeclaration - Parse C++0x or C11 static_assert-declaration.\n///\n/// [C++0x] static_assert-declaration:\n/// static_assert ( constant-expression , string-literal ) ;\n///\n/// [C11] static_assert-declaration:\n/// _Static_assert ( constant-expression , string-literal ) ;\n///\nDecl *Parser::ParseStaticAssertDeclaration(SourceLocation &DeclEnd) {\n // ...\n if (Tok.is(tok::kw_static_assert)) {\n if (!getLangOpts().CPlusPlus) {\n if (getLangOpts().C2x)\n Diag(Tok, diag::warn_c2x_compat_keyword) << Tok.getName();"},{"clang/lib/Parse/ParseDeclCXX.cpp",4504,"/// Parse a C++11 or C2x attribute-specifier.\n///\n/// [C++11] attribute-specifier:\n/// \'[\' \'[\' attribute-list \']\' \']\'\n/// alignment-specifier\n///\n/// [C++11] attribute-list:\n/// attribute[opt]\n/// attribute-list \',\' attribute[opt]\n/// attribute \'...\'\n/// attribute-list \',\' attribute \'...\'\n///\n/// [C++11] attribute:\n/// attribute-token attribute-argument-clause[opt]\n///\n/// [C++11] attribute-token:\n/// identifier\n/// attribute-scoped-token\n///\n/// [C++11] attribute-scoped-token:\n/// attribute-namespace \'::\' identifier\n///\n/// [C++11] attribute-namespace:\n/// identifier\nvoid Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs, CachedTokens &OpenMPTokens, SourceLocation *EndLoc) {\n if (Tok.is(tok::kw_alignas)) {\n if (getLangOpts().C2x)\n Diag(Tok, diag::warn_c2x_compat_keyword) << Tok.getName();"},{"clang/lib/Parse/ParseExpr.cpp",1014,"/// Parse a cast-expression, or, if \\pisUnaryExpression is true, parse\n/// a unary-expression.\n///\n/// \\p isAddressOfOperand exists because an id-expression that is the operand\n/// of address-of gets special treatment due to member pointers. NotCastExpr\n/// is set to true if the token is not the start of a cast-expression, and no\n/// diagnostic is emitted in this case and no tokens are consumed.\n///\n/// \\verbatim\n/// cast-expression: [C99 6.5.4]\n/// unary-expression\n/// \'(\' type-name \')\' cast-expression\n///\n/// unary-expression: [C99 6.5.3]\n/// postfix-expression\n/// \'++\' unary-expression\n/// \'--\' unary-expression\n/// [Coro] \'co_await\' cast-expression\n/// unary-operator cast-expression\n/// \'sizeof\' unary-expression\n/// \'sizeof\' \'(\' type-name \')\'\n/// [C++11] \'sizeof\' \'...\' \'(\' identifier \')\'\n/// [GNU] \'__alignof\' unary-expression\n/// [GNU] \'__alignof\' \'(\' type-name \')\'\n/// [C11] \'_Alignof\' \'(\' type-name \')\'\n/// [C++11] \'alignof\' \'(\' type-id \')\'\n/// [GNU] \'&&\' identifier\n/// [C++11] \'noexcept\' \'(\' expression \')\' [C++11 5.3.7]\n/// [C++] new-expression\n/// [C++] delete-expression\n///\n/// unary-operator: one of\n/// \'&\' \'*\' \'+\' \'-\' \'~\' \'!\'\n/// [GNU] \'__extension__\' \'__real\' \'__imag\'\n///\n/// primary-expression: [C99 6.5.1]\n/// [C99] identifier\n/// [C++] id-expression\n/// constant\n/// string-literal\n/// [C++] boolean-literal [C++ 2.13.5]\n/// [C++11] \'nullptr\' [C++11 2.14.7]\n/// [C++11] user-defined-literal\n/// \'(\' expression \')\'\n/// [C11] generic-selection\n/// [C++2a] requires-expression\n/// \'__func__\' [C99 6.4.2.2]\n/// [GNU] \'__FUNCTION__\'\n/// [MS] \'__FUNCDNAME__\'\n/// [MS] \'L__FUNCTION__\'\n/// [MS] \'__FUNCSIG__\'\n/// [MS] \'L__FUNCSIG__\'\n/// [GNU] \'__PRETTY_FUNCTION__\'\n/// [GNU] \'(\' compound-statement \')\'\n/// [GNU] \'__builtin_va_arg\' \'(\' assignment-expression \',\' type-name \')\'\n/// [GNU] \'__builtin_offsetof\' \'(\' type-name \',\' offsetof-member-designator\')\'\n/// [GNU] \'__builtin_choose_expr\' \'(\' assign-expr \',\' assign-expr \',\'\n/// assign-expr \')\'\n/// [GNU] \'__builtin_FILE\' \'(\' \')\'\n/// [CLANG] \'__builtin_FILE_NAME\' \'(\' \')\'\n/// [GNU] \'__builtin_FUNCTION\' \'(\' \')\'\n/// [MS] \'__builtin_FUNCSIG\' \'(\' \')\'\n/// [GNU] \'__builtin_LINE\' \'(\' \')\'\n/// [CLANG] \'__builtin_COLUMN\' \'(\' \')\'\n/// [GNU] \'__builtin_source_location\' \'(\' \')\'\n/// [GNU] \'__builtin_types_compatible_p\' \'(\' type-name \',\' type-name \')\'\n/// [GNU] \'__null\'\n/// [OBJC] \'[\' objc-message-expr \']\'\n/// [OBJC] \'\\@selector\' \'(\' objc-selector-arg \')\'\n/// [OBJC] \'\\@protocol\' \'(\' identifier \')\'\n/// [OBJC] \'\\@encode\' \'(\' type-name \')\'\n/// [OBJC] objc-string-literal\n/// [C++] simple-type-specifier \'(\' expression-list[opt] \')\' [C++ 5.2.3]\n/// [C++11] simple-type-specifier braced-init-list [C++11 5.2.3]\n/// [C++] typename-specifier \'(\' expression-list[opt] \')\' [C++ 5.2.3]\n/// [C++11] typename-specifier braced-init-list [C++11 5.2.3]\n/// [C++] \'const_cast\' \'<\' type-name \'>\' \'(\' expression \')\' [C++ 5.2p1]\n/// [C++] \'dynamic_cast\' \'<\' type-name \'>\' \'(\' expression \')\' [C++ 5.2p1]\n/// [C++] \'reinterpret_cast\' \'<\' type-name \'>\' \'(\' expression \')\' [C++ 5.2p1]\n/// [C++] \'static_cast\' \'<\' type-name \'>\' \'(\' expression \')\' [C++ 5.2p1]\n/// [C++] \'typeid\' \'(\' expression \')\' [C++ 5.2p1]\n/// [C++] \'typeid\' \'(\' type-id \')\' [C++ 5.2p1]\n/// [C++] \'this\' [C++ 9.3.2]\n/// [G++] unary-type-trait \'(\' type-id \')\'\n/// [G++] binary-type-trait \'(\' type-id \',\' type-id \')\' [TODO]\n/// [EMBT] array-type-trait \'(\' type-id \',\' integer \')\'\n/// [clang] \'^\' block-literal\n///\n/// constant: [C99 6.4.4]\n/// integer-constant\n/// floating-constant\n/// enumeration-constant -> identifier\n/// character-constant\n///\n/// id-expression: [C++ 5.1]\n/// unqualified-id\n/// qualified-id\n///\n/// unqualified-id: [C++ 5.1]\n/// identifier\n/// operator-function-id\n/// conversion-function-id\n/// \'~\' class-name\n/// template-id\n///\n/// new-expression: [C++ 5.3.4]\n/// \'::\'[opt] \'new\' new-placement[opt] new-type-id\n/// new-initializer[opt]\n/// \'::\'[opt] \'new\' new-placement[opt] \'(\' type-id \')\'\n/// new-initializer[opt]\n///\n/// delete-expression: [C++ 5.3.5]\n/// \'::\'[opt] \'delete\' cast-expression\n/// \'::\'[opt] \'delete\' \'[\' \']\' cast-expression\n///\n/// [GNU/Embarcadero] unary-type-trait:\n/// \'__is_arithmetic\'\n/// \'__is_floating_point\'\n/// \'__is_integral\'\n/// \'__is_lvalue_expr\'\n/// \'__is_rvalue_expr\'\n/// \'__is_complete_type\'\n/// \'__is_void\'\n/// \'__is_array\'\n/// \'__is_function\'\n/// \'__is_reference\'\n/// \'__is_lvalue_reference\'\n/// \'__is_rvalue_reference\'\n/// \'__is_fundamental\'\n/// \'__is_object\'\n/// \'__is_scalar\'\n/// \'__is_compound\'\n/// \'__is_pointer\'\n/// \'__is_member_object_pointer\'\n/// \'__is_member_function_pointer\'\n/// \'__is_member_pointer\'\n/// \'__is_const\'\n/// \'__is_volatile\'\n/// \'__is_trivial\'\n/// \'__is_standard_layout\'\n/// \'__is_signed\'\n/// \'__is_unsigned\'\n///\n/// [GNU] unary-type-trait:\n/// \'__has_nothrow_assign\'\n/// \'__has_nothrow_copy\'\n/// \'__has_nothrow_constructor\'\n/// \'__has_trivial_assign\' [TODO]\n/// \'__has_trivial_copy\' [TODO]\n/// \'__has_trivial_constructor\'\n/// \'__has_trivial_destructor\'\n/// \'__has_virtual_destructor\'\n/// \'__is_abstract\' [TODO]\n/// \'__is_class\'\n/// \'__is_empty\' [TODO]\n/// \'__is_enum\'\n/// \'__is_final\'\n/// \'__is_pod\'\n/// \'__is_polymorphic\'\n/// \'__is_sealed\' [MS]\n/// \'__is_trivial\'\n/// \'__is_union\'\n/// \'__has_unique_object_representations\'\n///\n/// [Clang] unary-type-trait:\n/// \'__is_aggregate\'\n/// \'__trivially_copyable\'\n///\n/// binary-type-trait:\n/// [GNU] \'__is_base_of\'\n/// [MS] \'__is_convertible_to\'\n/// \'__is_convertible\'\n/// \'__is_same\'\n///\n/// [Embarcadero] array-type-trait:\n/// \'__array_rank\'\n/// \'__array_extent\'\n///\n/// [Embarcadero] expression-trait:\n/// \'__is_lvalue_expr\'\n/// \'__is_rvalue_expr\'\n/// \\endverbatim\n///\nExprResult Parser::ParseCastExpression(CastParseKind ParseKind, bool isAddressOfOperand, bool &NotCastExpr, TypeCastState isTypeCast, bool isVectorLiteral, bool *NotPrimaryExpression) {\n // ...\n case tok::kw_nullptr:\n if (getLangOpts().CPlusPlus)\n // ...\n else\n Diag(Tok, getLangOpts().C2x ? diag::warn_c2x_compat_keyword : diag::ext_c_nullptr) << Tok.getName();"},{"clang/lib/Parse/ParseExpr.cpp",2497,"/// Parse a sizeof or alignof expression.\n///\n/// \\verbatim\n/// unary-expression: [C99 6.5.3]\n/// \'sizeof\' unary-expression\n/// \'sizeof\' \'(\' type-name \')\'\n/// [C++11] \'sizeof\' \'...\' \'(\' identifier \')\'\n/// [GNU] \'__alignof\' unary-expression\n/// [GNU] \'__alignof\' \'(\' type-name \')\'\n/// [C11] \'_Alignof\' \'(\' type-name \')\'\n/// [C++11] \'alignof\' \'(\' type-id \')\'\n/// \\endverbatim\nExprResult Parser::ParseUnaryExprOrTypeTraitExpression() {\n // ...\n if (getLangOpts().CPlusPlus && OpTok.isOneOf(tok::kw_alignof, tok::kw__Alignof))\n // ...\n else if (getLangOpts().C2x && OpTok.is(tok::kw_alignof))\n Diag(OpTok, diag::warn_c2x_compat_keyword) << OpTok.getName();"}},
[l]={
["clang/test/C/C2x/n2934.c"]={"clang/test/C/C2x/n2934.c:8:1: warning: \'thread_local\' is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2934.c:8:21: warning: \'alignas\' is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2934.c:15:3: warning: \'bool\' is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2934.c:18:1: warning: \'static_assert\' is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2934.c:18:15: warning: \'alignof\' is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/C/C2x/n2934.c:18:36: warning: \'alignof\' is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_label_end_of_compound_statement"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,v,"warn_c2x_compat_label_end_of_compound_statement"}},
[b]={{nil,v,"label at end of compound statement is incompatible with C standards before C2x"}},
[c]={{nil,v,"label at end of compound statement is incompatible with C standards before C2x"}},
[d]=m,
[e]="label at end of compound statement is incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,v,db}},
[a]={"782ac2182c2b",1657907157,"[HLSL] Support cbuffer/tbuffer for hlsl.","[HLSL] Support cbuffer/tbuffer for hlsl.\n\nThis is first part for support cbuffer/tbuffer.\n\nThe format for cbuffer/tbuffer is\nBufferType [Name] [: register(b#)] { VariableDeclaration [: packoffset(c#.xyzw)]; ... };\n\nMore details at https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/dx-graphics-hlsl-constants\n\nNew keyword \'cbuffer\' and \'tbuffer\' are added.\nNew AST node HLSLBufferDecl is added.\nBuild AST for simple cbuffer/tbuffer without attribute support.\n\nThe special thing is variables declared inside cbuffer is exposed into global scope.\nSo isTransparentContext should return true for HLSLBuffer.\n\nReviewed By: aaron.ballman\n\nDifferential Revision: https://reviews.llvm.org/D129883"},
[i]={{"clang/lib/Parse/ParseStmt.cpp",1080,"void Parser::DiagnoseLabelAtEndOfCompoundStatement() {\n if (getLangOpts().CPlusPlus) {\n // ...\n } else {\n Diag(Tok, getLangOpts().C2x ? diag::warn_c2x_compat_label_end_of_compound_statement : diag::ext_c_label_end_of_compound_statement);"}},
[l]={
["clang/test/Parser/c2x-label.c"]={"clang/test/Parser/c2x-label.c:9:1: warning: label at end of compound statement is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/Parser/c2x-label.c:19:5: warning: label at end of compound statement is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/Parser/c2x-label.c:26:5: warning: label at end of compound statement is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_literal_ucn_control_character"]={
[j]={Q,nb},
[k]=Q,
[g]="warn_c2x_compat_literal_ucn_control_character",
[b]="universal character name referring to a control character is incompatible with C standards before C2x",
[c]="universal character name referring to a control character is incompatible with C standards before C2x",
[d]=m,
[e]="universal character name referring to a control character is incompatible with C standards before C2x",
[f]=ob,
[h]=A,
[a]={"304e97469455",1687518157,"[Clang] Correctly handle $, @, and ` when represented as UCN","[Clang] Correctly handle $, @, and ` when represented as UCN\n\nThis covers\n * P2558R2 (C++, wg21.link/P2558)\n * N2701 (C, https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2701.htm)\n * N3124 (C, https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3124.pdf)\n\nThis patch\n * Disallow representing $ as a UCN in all language mode, which did not\n properly work (see GH62133), and which in made ill-formed in\n C++ and C by P2558 and N3124 respectively\n * Allow a UCN for any character in C2X, in string and character\n literals\n\nFixes #62133\n\nReviewed By: #clang-language-wg, tahonermann\n\nDifferential Revision: https://reviews.llvm.org/D153621"},
[i]={{Dc,687,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n // ...\n // C2x and C++11 allow UCNs that refer to control characters\n // and basic source characters inside character and string literals\n if (UcnVal < 0xa0 &&\n // ...\n if (Diags) {\n // ...\n if (UcnVal >= 0x20 && UcnVal < 0x7f)\n // ...\n else\n Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, IsError ? diag::err_ucn_control_character : Features.CPlusPlus ? diag::warn_cxx98_compat_literal_ucn_control_character : diag::warn_c2x_compat_literal_ucn_control_character);"}}
},
["warn_c2x_compat_literal_ucn_escape_basic_scs"]={
[j]={Q,nb},
[k]=Q,
[g]="warn_c2x_compat_literal_ucn_escape_basic_scs",
[b]="specifying character \'%0\' with a universal character name is incompatible with C standards before C2x",
[c]="specifying character \'A\' with a universal character name is incompatible with C standards before C2x",
[d]=m,
[e]="specifying character \'(.*?)\' with a universal character name is incompatible with C standards before C2x",
[f]=ob,
[h]=A,
[a]={"304e97469455",1687518157,"[Clang] Correctly handle $, @, and ` when represented as UCN","[Clang] Correctly handle $, @, and ` when represented as UCN\n\nThis covers\n * P2558R2 (C++, wg21.link/P2558)\n * N2701 (C, https://www.open-std.org/jtc1/sc22/wg14/www/docs/n2701.htm)\n * N3124 (C, https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3124.pdf)\n\nThis patch\n * Disallow representing $ as a UCN in all language mode, which did not\n properly work (see GH62133), and which in made ill-formed in\n C++ and C by P2558 and N3124 respectively\n * Allow a UCN for any character in C2X, in string and character\n literals\n\nFixes #62133\n\nReviewed By: #clang-language-wg, tahonermann\n\nDifferential Revision: https://reviews.llvm.org/D153621"},
[i]={{Dc,680,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n // ...\n // C2x and C++11 allow UCNs that refer to control characters\n // and basic source characters inside character and string literals\n if (UcnVal < 0xa0 &&\n // ...\n if (Diags) {\n // ...\n if (UcnVal >= 0x20 && UcnVal < 0x7f)\n Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, IsError ? diag::err_ucn_escape_basic_scs : Features.CPlusPlus ? diag::warn_cxx98_compat_literal_ucn_escape_basic_scs : diag::warn_c2x_compat_literal_ucn_escape_basic_scs) << StringRef(&BasicSCSChar, 1);"}}
},
["warn_c2x_compat_pp_directive"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,D,"warn_c2x_compat_pp_directive"}},
[b]={{nil,D,"use of a \'#%select{<BUG IF SEEN>|elifdef|elifndef}0\' directive is incompatible with C standards before C2x"}},
[c]={{nil,D,{"use of a \'#",{"elifdef","elifndef"},"\' directive is incompatible with C standards before C2x"}}},
[d]=m,
[e]="use of a \'\\#(?:elifdef|elifndef)\' directive is incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,D,A}},
[a]={sb,1625925174,rb,vb},
[i]={{S,771,"/// SkipExcludedConditionalBlock - We just read a \\#if or related directive and\n/// decided that the subsequent tokens are in the \\#if\'d out portion of the\n/// file. Lex the rest of the file, until we see an \\#endif. If\n/// FoundNonSkipPortion is true, then we have already emitted code for part of\n/// this \\#if directive, so \\#else/\\#elif blocks should never be entered.\n/// If ElseOk is true, then \\#else directives are ok, if not, then we have\n/// already seen one so a \\#else directive is a duplicate. When this returns,\n/// the caller can lex the first valid token.\nvoid Preprocessor::SkipExcludedConditionalBlock(SourceLocation HashTokenLoc, SourceLocation IfTokenLoc, bool FoundNonSkipPortion, bool FoundElse, SourceLocation ElseLoc) {\n // ...\n while (true) {\n // ...\n if (Directive.startswith(\"if\")) {\n // ...\n } else if (Directive[0] == \'e\') {\n // ...\n if (Sub == \"ndif\") { // \"endif\"\n // ...\n } else if (Sub == \"lse\") { // \"else\".\n // ...\n } else if (Sub == \"lif\") { // \"elif\".\n // ...\n } else if (Sub == \"lifdef\" || // \"elifdef\"\n // ...\n if (LangOpts.CPlusPlus)\n // ...\n else\n DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive : diag::ext_c2x_pp_directive;"},{S,3457,"/// Implements the \\#elif, \\#elifdef, and \\#elifndef directives.\nvoid Preprocessor::HandleElifFamilyDirective(Token &ElifToken, const Token &HashToken, tok::PPKeywordKind Kind) {\n // ...\n case PED_Elifdef:\n case PED_Elifndef:\n // ...\n if (LangOpts.CPlusPlus)\n // ...\n else\n DiagID = LangOpts.C2x ? diag::warn_c2x_compat_pp_directive : diag::ext_c2x_pp_directive;"}},
[l]={
["clang/test/Preprocessor/ext-pp-directive.c"]={"clang/test/Preprocessor/ext-pp-directive.c:18:2: warning: use of a \'#elifdef\' directive is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/Preprocessor/ext-pp-directive.c:29:2: warning: use of a \'#elifndef\' directive is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/Preprocessor/ext-pp-directive.c:40:2: warning: use of a \'#elifdef\' directive is incompatible with C standards before C2x [-Wpre-c2x-compat]","clang/test/Preprocessor/ext-pp-directive.c:51:2: warning: use of a \'#elifndef\' directive is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_compat_warning_directive"]={
[j]={Q,nb},
[k]=Q,
[g]={{nil,D,"warn_c2x_compat_warning_directive"}},
[b]={{nil,D,"#warning is incompatible with C standards before C2x"}},
[c]={{nil,D,"#warning is incompatible with C standards before C2x"}},
[d]=m,
[e]="\\#warning is incompatible with C standards before C2x",
[f]=ob,
[h]={{nil,D,A}},
[a]={sb,1625925174,rb,vb},
[i]={{S,1281,"/// HandleDirective - This callback is invoked when the lexer sees a # token\n/// at the start of a line. This consumes the directive, modifies the\n/// lexer/preprocessor state, and advances the lexer(s) so that the next token\n/// read is the correct one.\nvoid Preprocessor::HandleDirective(Token &Result) {\n // ...\n default:\n // ...\n case tok::pp_warning:\n if (LangOpts.CPlusPlus)\n // ...\n else\n Diag(Result, LangOpts.C2x ? diag::warn_c2x_compat_warning_directive : diag::ext_pp_warning_directive) << /*C2x*/ 0;"}},
[l]={
["clang/test/Preprocessor/ext-pp-directive.c"]={"clang/test/Preprocessor/ext-pp-directive.c:61:2: warning: #warning is incompatible with C standards before C2x [-Wpre-c2x-compat]"}
}
},
["warn_c2x_keyword"]={
[j]={"c2x-compat"},
[k]="c2x-compat",
[g]={{nil,v,"warn_c2x_keyword"}},
[b]={{nil,v,"\'%0\' is a keyword in C2x"}},
[c]={{nil,v,"\'A\' is a keyword in C2x"}},
[d]=m,
[e]="\'(.*?)\' is a keyword in C2x",
[f]=" \\[(?:\\-Werror,)?\\-Wc2x\\-compat[^\\]]*\\]",
[h]={{nil,v,A}},
[a]={sb,1625925174,rb,vb},
[i]={{"clang/lib/Basic/IdentifierTable.cpp",919,"#include \"clang/Basic/TokenKinds.def\"\n // ...\n if (LangOpts.CPlusPlus) {\n // ...\n } else {\n // ...\n if ((Flags & KEYC2X) == KEYC2X)\n return diag::warn_c2x_keyword;"}},
[l]={
["clang/test/Sema/nullptr-prec2x.c"]={"clang/test/Sema/nullptr-prec2x.c:5:5: warning: \'nullptr\' is a keyword in C2x [-Wc2x-compat]"}
}
},
["warn_c99_compat_unicode_id"]={
[j]={dc},
[k]=dc,
[g]="warn_c99_compat_unicode_id",
[b]="%select{using this character in an identifier|starting an identifier with this character}0 is incompatible with C99",
[c]={{nil,nil,{{"using this character in an identifier","starting an identifier with this character"}," is incompatible with C99"}}},
[d]=m,
[e]="(?:using this character in an identifier|starting an identifier with this character) is incompatible with C99",
[f]=" \\[(?:\\-Werror,)?\\-Wc99\\-compat[^\\]]*\\]",
[h]=A,
[a]={"58c61e006f4d",1360372225,"Properly validate UCNs for C99 and C++03 (both more restrictive than C(++)11).","Properly validate UCNs for C99 and C++03 (both more restrictive than C(++)11).\n\nAdd warnings under -Wc++11-compat, -Wc++98-compat, and -Wc99-compat when a\nparticular UCN is incompatible with a different standard, and -Wunicode when\na UCN refers to a surrogate character in C++03.\n\nllvm-svn: 174788"},
[i]={{bb,1569,"static void maybeDiagnoseIDCharCompat(DiagnosticsEngine &Diags, uint32_t C, CharSourceRange Range, bool IsFirst) {\n // ...\n if (!Diags.isIgnored(diag::warn_c99_compat_unicode_id, Range.getBegin())) {"},{bb,1580,"static void maybeDiagnoseIDCharCompat(DiagnosticsEngine &Diags, uint32_t C, CharSourceRange Range, bool IsFirst) {\n // Check C99 compatibility.\n if (!Diags.isIgnored(diag::warn_c99_compat_unicode_id, Range.getBegin())) {\n // ...\n if (!C99AllowedIDChars.contains(C)) {\n Diags.Report(Range.getBegin(), diag::warn_c99_compat_unicode_id) << Range << CannotAppearInIdentifier;"},{bb,1584,"static void maybeDiagnoseIDCharCompat(DiagnosticsEngine &Diags, uint32_t C, CharSourceRange Range, bool IsFirst) {\n // Check C99 compatibility.\n if (!Diags.isIgnored(diag::warn_c99_compat_unicode_id, Range.getBegin())) {\n // ...\n if (!C99AllowedIDChars.contains(C)) {\n // ...\n } else if (IsFirst && C99DisallowedInitialIDChars.contains(C)) {\n Diags.Report(Range.getBegin(), diag::warn_c99_compat_unicode_id) << Range << CannotStartIdentifier;"}},
[l]={
["clang/test/Preprocessor/utf8-allowed-chars.c"]={"clang/test/Preprocessor/utf8-allowed-chars.c:9:14: warning: using this character in an identifier is incompatible with C99 [-Wc99-compat]","clang/test/Preprocessor/utf8-allowed-chars.c:11:14: warning: using this character in an identifier is incompatible with C99 [-Wc99-compat]","clang/test/Preprocessor/utf8-allowed-chars.c:14:14: warning: using this character in an identifier is incompatible with C99 [-Wc99-compat]","clang/test/Preprocessor/utf8-allowed-chars.c:20:13: warning: starting an identifier with this character is incompatible with C99 [-Wc99-compat]"}
}
},
["warn_c99_compat_unicode_literal"]={
[j]={dc},
[k]=dc,
[g]="warn_c99_compat_unicode_literal",
[b]="unicode literals are incompatible with C99",
[c]="unicode literals are incompatible with C99",
[d]=m,
[e]="unicode literals are incompatible with C99",
[f]=" \\[(?:\\-Werror,)?\\-Wc99\\-compat[^\\]]*\\]",
[h]=A,
[a]={"06d274fdb7c8",1363024902,"Add -Wc99-compat warning for C11 unicode string and character literals.","Add -Wc99-compat warning for C11 unicode string and character literals.\n\nllvm-svn: 176817"},
[i]={{bb,2088,"/// LexStringLiteral - Lex the remainder of a string literal, after having lexed\n/// either \" or L\" or u8\" or u\" or U\".\nbool Lexer::LexStringLiteral(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n // ...\n if (!isLexingRawMode() && (Kind == tok::utf8_string_literal || Kind == tok::utf16_string_literal || Kind == tok::utf32_string_literal))\n Diag(BufferPtr, LangOpts.CPlusPlus ? diag::warn_cxx98_compat_unicode_literal : diag::warn_c99_compat_unicode_literal);"},{bb,2304,"/// LexCharConstant - Lex the remainder of a character constant, after having\n/// lexed either \' or L\' or u8\' or u\' or U\'.\nbool Lexer::LexCharConstant(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n // ...\n if (!isLexingRawMode()) {\n if (Kind == tok::utf16_char_constant || Kind == tok::utf32_char_constant)\n Diag(BufferPtr, LangOpts.CPlusPlus ? diag::warn_cxx98_compat_unicode_literal : diag::warn_c99_compat_unicode_literal);"}},
[l]={
["clang/test/Lexer/unicode-strings.c"]={"clang/test/Lexer/unicode-strings.c:16:17: warning: unicode literals are incompatible with C99 [-Wc99-compat]","clang/test/Lexer/unicode-strings.c:17:21: warning: unicode literals are incompatible with C99 [-Wc99-compat]","clang/test/Lexer/unicode-strings.c:18:21: warning: unicode literals are incompatible with C99 [-Wc99-compat]","clang/test/Lexer/unicode-strings.c:20:14: warning: unicode literals are incompatible with C99 [-Wc99-compat]","clang/test/Lexer/unicode-strings.c:21:14: warning: unicode literals are incompatible with C99 [-Wc99-compat]"}
}
},
["warn_c99_keyword"]={
[j]={dc},
[k]=dc,
[g]={{nil,v,"warn_c99_keyword"}},
[b]={{nil,v,"\'%0\' is a keyword in C99"}},
[c]={{nil,v,"\'A\' is a keyword in C99"}},
[d]=m,
[e]="\'(.*?)\' is a keyword in C99",
[f]=" \\[(?:\\-Werror,)?\\-Wc99\\-compat[^\\]]*\\]",
[h]={{nil,v,A}},
[a]={sb,1625925174,rb,vb},
[i]={{"clang/lib/Basic/IdentifierTable.cpp",917,"#include \"clang/Basic/TokenKinds.def\"\n // ...\n if (LangOpts.CPlusPlus) {\n // ...\n } else {\n if ((Flags & KEYC99) == KEYC99)\n return diag::warn_c99_keyword;"}},
[l]={
["clang/test/Lexer/keywords_test.c"]={"clang/test/Lexer/keywords_test.c:93:7: warning: \'restrict\' is a keyword in C99 [-Wc99-compat]","clang/test/Lexer/keywords_test.c:94:7: warning: \'inline\' is a keyword in C99 [-Wc99-compat]"}
}
},
["warn_c_kext"]={
[g]="warn_c_kext",
[b]="ignoring -fapple-kext which is valid for C++ and Objective-C++ only",
[c]="ignoring -fapple-kext which is valid for C++ and Objective-C++ only",
[d]=m,
[e]="ignoring \\-fapple\\-kext which is valid for C\\+\\+ and Objective\\-C\\+\\+ only",
[f]=jb,
[h]=O,
[a]={"f7f04458b3d1",1296777684,"-fapple-kext cannot have \'weak\' visibility in this","-fapple-kext cannot have \'weak\' visibility in this\nabi.\n\nllvm-svn: 124834"},
[i]={{"clang/lib/Frontend/CompilerInvocation.cpp",498,"static bool FixupInvocation(CompilerInvocation &Invocation, DiagnosticsEngine &Diags, const ArgList &Args, InputKind IK) {\n // ...\n if (LangOpts.AppleKext && !LangOpts.CPlusPlus)\n Diags.Report(diag::warn_c_kext);"}}
},
["warn_call_to_pure_virtual_member_function_from_ctor_dtor"]={
[j]={"call-to-pure-virtual-from-ctor-dtor"},
[k]="call-to-pure-virtual-from-ctor-dtor",
[g]="warn_call_to_pure_virtual_member_function_from_ctor_dtor",
[b]="call to pure virtual member function %0 has undefined behavior; overrides of %0 in subclasses are not available in the %select{constructor|destructor}1 of %2",
[c]={{nil,nil,{"call to pure virtual member function A has undefined behavior; overrides of A in subclasses are not available in the ",{"constructor","destructor"}," of C"}}},
[d]=m,
[e]="call to pure virtual member function (.*?) has undefined behavior; overrides of (.*?) in subclasses are not available in the (?:constructor|destructor) of (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wcall\\-to\\-pure\\-virtual\\-from\\-ctor\\-dtor[^\\]]*\\]",
[h]=n,
[a]={"47061ee5bc64",1304691931,"Warn when trying to call a pure virtual member function in a class from the class constructor/destru...","Warn when trying to call a pure virtual member function in a class from the class constructor/destructor. Fixes PR7966.\n\nllvm-svn: 130982"},
[i]={{"clang/lib/Sema/SemaOverload.cpp",14920,"/// BuildCallToMemberFunction - Build a call to a member\n/// function. MemExpr is the expression that refers to the member\n/// function (and includes the object parameter), Args/NumArgs are the\n/// arguments to the function call (not including the object\n/// parameter). The caller needs to validate that the member\n/// expression refers to a non-static member function or an overloaded\n/// member function.\nExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n // ...\n if ((isa<CXXConstructorDecl>(CurContext) || isa<CXXDestructorDecl>(CurContext)) && TheCall->getMethodDecl()->isPure()) {\n // ...\n if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) && MemExpr->performsVirtualDispatch(getLangOpts())) {\n Diag(MemExpr->getBeginLoc(), diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor) << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext) << MD->getParent();"}},
[l]={
["clang/test/SemaCXX/warn-pure-virtual-kext.cpp"]={"clang/test/SemaCXX/warn-pure-virtual-kext.cpp:6:9: warning: call to pure virtual member function \'f\' has undefined behavior; overrides of \'f\' in subclasses are not available in the constructor of \'A\' [-Wcall-to-pure-virtual-from-ctor-dtor]","clang/test/SemaCXX/warn-pure-virtual-kext.cpp:13:10: warning: call to pure virtual member function \'f\' has undefined behavior; overrides of \'f\' in subclasses are not available in the constructor of \'TA<int>\' [-Wcall-to-pure-virtual-from-ctor-dtor]"}
}
},
["warn_call_wrong_number_of_arguments"]={
[g]="warn_call_wrong_number_of_arguments",
[b]="too %select{few|many}0 arguments in call to %1",
[c]={{nil,nil,{"too ",{"few","many"}," arguments in call to B"}}},
[d]=m,
[e]="too (?:few|many) arguments in call to (.*?)",
[f]=jb,
[h]=n,
[a]={"d8e97def584d",1238686630,"When calling a function without a prototype for which we have a","When calling a function without a prototype for which we have a\ndefinition, warn if there are too many/too few function call\narguments.\n\nllvm-svn: 68318"},
[i]={{G,7555,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy. The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n // ...\n if (Proto) {\n // ...\n } else {\n // ...\n if (FDecl) {\n // ...\n if (FDecl->hasBody(Def) && Args.size() != Def->param_size()) {\n // ...\n if (!Proto || !(Proto->isVariadic() && Args.size() >= Def->param_size()))\n Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) << (Args.size() > Def->param_size()) << FDecl << Fn->getSourceRange();"}},
[l]={
["clang/test/Sema/knr-def-call.c"]={"clang/test/Sema/knr-def-call.c:6:7: warning: too few arguments in call to \'f0\'","clang/test/Sema/knr-def-call.c:11:13: warning: too many arguments in call to \'f1\'"}
}
},
["warn_called_once_gets_called_twice"]={
[j]={Ab},
[k]=Ab,
[g]={{nil,p,"warn_called_once_gets_called_twice"}},
[b]={{nil,p,"%0 parameter marked \'called_once\' is called twice"}},
[c]={{nil,p,"A parameter marked \'called_once\' is called twice"}},
[d]=m,
[e]="(.*?) parameter marked \'called_once\' is called twice",
[f]=" \\[(?:\\-Werror,)?\\-Wcalled\\-once\\-parameter[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{M,1690,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleDoubleCall(const ParmVarDecl *Parameter, const Expr *Call, const Expr *PrevCall, bool IsCompletionHandler, bool Poised) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_called_twice : diag::warn_called_once_gets_called_twice;"},{M,1752,"constexpr unsigned CalledOnceWarnings[] = {diag::warn_called_once_never_called, diag::warn_called_once_never_called_when, diag::warn_called_once_gets_called_twice};"}},
[l]={
[hc]={"clang/test/SemaObjC/warn-called-once.m:54:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:59:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:64:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:69:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:78:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:87:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:95:5: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:119:5: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:128:5: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:183:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:191:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:203:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:225:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:243:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:259:5: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:281:5: warning: \'inner\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:284:3: warning: \'outer\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:309:5: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:539:7: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:793:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:799:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:865:3: warning: \'callback\' parameter marked \'called_once\' is called twice [-Wcalled-once-parameter]"}
}
},
["warn_called_once_never_called"]={
[j]={Ab},
[k]=Ab,
[g]={{nil,p,"warn_called_once_never_called"}},
[b]={{nil,p,"%select{|captured }1%0 parameter marked \'called_once\' is never called"}},
[c]={{nil,p,{{r,"captured "},"A parameter marked \'called_once\' is never called"}}},
[d]=m,
[e]="(?:|captured )(.*?) parameter marked \'called_once\' is never called",
[f]=" \\[(?:\\-Werror,)?\\-Wcalled\\-once\\-parameter[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{M,1700,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleNeverCalled(const ParmVarDecl *Parameter, bool IsCompletionHandler) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_never_called : diag::warn_called_once_never_called;"},{M,1730,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleCapturedNeverCalled(const ParmVarDecl *Parameter, const Decl *Where, bool IsCompletionHandler) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_never_called : diag::warn_called_once_never_called;"},{M,1750,"constexpr unsigned CalledOnceWarnings[] = {diag::warn_called_once_never_called, diag::warn_called_once_never_called_when, diag::warn_called_once_gets_called_twice};"}},
[l]={
[hc]={"clang/test/SemaObjC/warn-called-once.m:133:27: warning: \'callback\' parameter marked \'called_once\' is never called [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:137:35: warning: \'callback\' parameter marked \'called_once\' is never called [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:273:5: warning: \'inner\' parameter marked \'called_once\' is never called [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:527:40: warning: \'callback\' parameter marked \'called_once\' is never called [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:718:49: warning: \'callback\' parameter marked \'called_once\' is never called [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:838:31: warning: \'callback\' parameter marked \'called_once\' is never called [-Wcalled-once-parameter]"}
}
},
["warn_called_once_never_called_when"]={
[j]={Ab},
[k]=Ab,
[g]={{nil,p,"warn_called_once_never_called_when"}},
[b]={{nil,p,"%0 parameter marked \'called_once\' is never %select{used|called}1 when %select{taking true branch|taking false branch|handling this case|none of the cases applies|entering the loop|skipping the loop|taking one of the branches}2"}},
[c]={{nil,p,{"A parameter marked \'called_once\' is never ",{"used","called"}," when ",{"taking true branch","taking false branch","handling this case","none of the cases applies","entering the loop","skipping the loop","taking one of the branches"}}}},
[d]=m,
[e]="(.*?) parameter marked \'called_once\' is never (?:used|called) when (?:taking true branch|taking false branch|handling this case|none of the cases applies|entering the loop|skipping the loop|taking one of the branches)",
[f]=" \\[(?:\\-Werror,)?\\-Wcalled\\-once\\-parameter[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{M,1711,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleNeverCalled(const ParmVarDecl *Parameter, const Decl *Function, const Stmt *Where, NeverCalledReason Reason, bool IsCalledDirectly, bool IsCompletionHandler) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_never_called_when : diag::warn_called_once_never_called_when;"},{M,1751,"constexpr unsigned CalledOnceWarnings[] = {diag::warn_called_once_never_called, diag::warn_called_once_never_called_when, diag::warn_called_once_gets_called_twice};"}},
[l]={
[hc]={"clang/test/SemaObjC/warn-called-once.m:174:3: warning: \'callback\' parameter marked \'called_once\' is never used when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:265:5: warning: \'callback\' parameter marked \'called_once\' is never used when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:289:5: warning: \'callback\' parameter marked \'called_once\' is never called when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:314:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking true branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:321:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking true branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:328:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking true branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:338:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:345:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:352:5: warning: \'callback\' parameter marked \'called_once\' is never called when taking true branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:351:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:360:10: warning: \'callback\' parameter marked \'called_once\' is never called when taking true branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:366:3: warning: \'callback\' parameter marked \'called_once\' is never called when skipping the loop [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:374:3: warning: \'callback\' parameter marked \'called_once\' is never called when entering the loop [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:382:3: warning: \'callback\' parameter marked \'called_once\' is never called when skipping the loop [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:389:3: warning: \'callback\' parameter marked \'called_once\' is never called when entering the loop [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:403:3: warning: \'callback\' parameter marked \'called_once\' is never called when handling this case [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:419:3: warning: \'callback\' parameter marked \'called_once\' is never called when handling this case [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:428:3: warning: \'callback\' parameter marked \'called_once\' is never called when handling this case [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:426:3: warning: \'callback\' parameter marked \'called_once\' is never called when handling this case [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:437:3: warning: \'callback\' parameter marked \'called_once\' is never called when none of the cases applies [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:737:3: warning: \'callback\' parameter marked \'called_once\' is never called when taking true branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:762:3: warning: \'callback\' parameter marked \'called_once\' is never used when taking false branch [-Wcalled-once-parameter]","clang/test/SemaObjC/warn-called-once.m:871:15: warning: \'callback\' parameter marked \'called_once\' is never used when taking false branch [-Wcalled-once-parameter]"}
}
},
["warn_cannot_pass_non_pod_arg_to_vararg"]={
[j]={"class-varargs","non-pod-varargs"},
[k]="non-pod-varargs",
[g]="warn_cannot_pass_non_pod_arg_to_vararg",
[b]="cannot pass object of %select{non-POD|non-trivial}0 type %1 through variadic %select{function|block|method|constructor}2; call will abort at runtime",
[c]={{nil,nil,{"cannot pass object of ",{"non-POD","non-trivial"}," type B through variadic ",{sc,"block","method","constructor"},"; call will abort at runtime"}}},
[d]=zc,
[e]="cannot pass object of (?:non\\-POD|non\\-trivial) type (.*?) through variadic (?:function|block|method|constructor); call will abort at runtime",
[f]=" \\[[^\\]]*\\-Wnon\\-pod\\-varargs[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{G,1013,"void Sema::checkVariadicArgument(const Expr *E, VariadicCallType CT) {\n // ...\n case VAK_Undefined:\n case VAK_MSVCUndefined:\n DiagRuntimeBehavior(E->getBeginLoc(), nullptr, PDiag(diag::warn_cannot_pass_non_pod_arg_to_vararg) << getLangOpts().CPlusPlus11 << Ty << CT);"}},
[l]={
["clang/test/CXX/expr/expr.post/expr.call/p7-0x.cpp"]={"clang/test/CXX/expr/expr.post/expr.call/p7-0x.cpp:27:10: error: cannot pass object of non-trivial type \'X2\' through variadic function; call will abort at runtime [-Wnon-pod-varargs]","clang/test/CXX/expr/expr.post/expr.call/p7-0x.cpp:29:10: error: cannot pass object of non-trivial type \'X4\' through variadic function; call will abort at runtime [-Wnon-pod-varargs]"}
}
},
["warn_cannot_resolve_lock"]={
[j]={"thread-safety",Zb},
[k]=Zb,
[g]="warn_cannot_resolve_lock",
[b]="cannot resolve lock expression",
[c]="cannot resolve lock expression",
[d]=m,
[e]="cannot resolve lock expression",
[f]=" \\[(?:\\-Werror,)?\\-Wthread\\-safety\\-analysis[^\\]]*\\]",
[h]=n,
[a]={"ff2f3f810525",1315585315,"Thread safety: This patch deals with previously unhandled cases when building lock expressions. We n...","Thread safety: This patch deals with previously unhandled cases when building lock expressions. We now resolve this expressions, avoid crashing when encountering cast expressions, and have a diagnostic for unresolved lock expressions\n\nllvm-svn: 139370"},
[i]={{M,1864,"class ThreadSafetyReporter : public clang::threadSafety::ThreadSafetyHandler {\n // ...\n void handleInvalidLockExp(SourceLocation Loc) override {\n PartialDiagnosticAt Warning(Loc, S.PDiag(diag::warn_cannot_resolve_lock) << Loc);"}}
},
["warn_case_empty_range"]={
[g]="warn_case_empty_range",
[b]="empty case range specified",
[c]="empty case range specified",
[d]=m,
[e]="empty case range specified",
[f]=jb,
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{X,1420,"StmtResult Sema::ActOnFinishSwitchStmt(SourceLocation SwitchLoc, Stmt *Switch, Stmt *BodyStmt) {\n // ...\n if (!HasDependentValue) {\n // ...\n // Detect duplicate case ranges, which usually don\'t exist at all in\n // the first place.\n if (!CaseRanges.empty()) {\n // ...\n for (unsigned i = 0, e = CaseRanges.size(); i != e; ++i) {\n // ...\n // If the low value is bigger than the high value, the case is empty.\n if (LoVal > HiVal) {\n Diag(CR->getLHS()->getBeginLoc(), diag::warn_case_empty_range) << SourceRange(CR->getLHS()->getBeginLoc(), Hi->getEndLoc());"}},
[l]={
["clang/test/Sema/switch.c"]={"clang/test/Sema/switch.c:15:8: warning: empty case range specified"}
}
},
["warn_case_value_overflow"]={
[j]={P,T,"switch"},
[k]="switch",
[g]="warn_case_value_overflow",
[b]="overflow converting case value to switch condition type (%0 to %1)",
[c]="overflow converting case value to switch condition type (A to B)",
[d]=m,
[e]="overflow converting case value to switch condition type \\((.*?) to (.*?)\\)",
[f]=" \\[(?:\\-Werror,)?\\-Wswitch[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{X,1149,"/// Check the specified case value is in range for the given unpromoted switch\n/// type.\nstatic void checkCaseValue(Sema &S, SourceLocation Loc, const llvm::APSInt &Val, unsigned UnpromotedWidth, bool UnpromotedSign) {\n // ...\n // If the case value was signed and negative and the switch expression is\n // unsigned, don\'t bother to warn: this is implementation-defined behavior.\n // FIXME: Introduce a second, default-ignored warning for this case?\n if (UnpromotedWidth < Val.getBitWidth()) {\n // ...\n // FIXME: Use different diagnostics for overflow in conversion to promoted\n // type versus \"switch expression cannot have this value\". Use proper\n // IntRange checking rather than just looking at the unpromoted type here.\n if (ConvVal != Val)\n S.Diag(Loc, diag::warn_case_value_overflow) << toString(Val, 10) << toString(ConvVal, 10);"}},
[l]={
["clang/test/Sema/switch.c"]={"clang/test/Sema/switch.c:11:8: warning: overflow converting case value to switch condition type (5000000000 to 705032704) [-Wswitch]","clang/test/Sema/switch.c:79:10: warning: overflow converting case value to switch condition type (1234 to -46) [-Wswitch]","clang/test/Sema/switch.c:393:27: warning: overflow converting case value to switch condition type (257 to 1) [-Wswitch]","clang/test/Sema/switch.c:395:19: warning: overflow converting case value to switch condition type (4294967297 to 1) [-Wswitch]","clang/test/Sema/switch.c:396:25: warning: overflow converting case value to switch condition type (4294967297 to 1) [-Wswitch]"}
}
},
["warn_cast_align"]={
[j]={"cast-align"},
[k]="cast-align",
[g]="warn_cast_align",
[b]="cast from %0 to %1 increases required alignment from %2 to %3",
[c]="cast from A to B increases required alignment from C to D",
[d]=m,
[e]="cast from (.*?) to (.*?) increases required alignment from (.*?) to (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-align[^\\]]*\\]",
[h]=n,
[a]={"2b5c1b2516ca",1281649497,"Implement -Wcast-align. The initial design of this diagnostic diverges ","Implement -Wcast-align. The initial design of this diagnostic diverges \nfrom GCC\'s in that we warn on *any* increase in alignment requirements, not\njust those that are enforced by hardware. Please let us know if this causes\nmajor problems for you (which it shouldn\'t, since it\'s an optional warning).\n\nllvm-svn: 110959"},
[i]={{u,16961,"/// CheckCastAlign - Implements -Wcast-align, which warns when a\n/// pointer cast increases the alignment requirements.\nvoid Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) {\n // ...\n if (getDiagnostics().isIgnored(diag::warn_cast_align, TRange.getBegin()))"},{u,16993,"/// CheckCastAlign - Implements -Wcast-align, which warns when a\n/// pointer cast increases the alignment requirements.\nvoid Sema::CheckCastAlign(Expr *Op, QualType T, SourceRange TRange) {\n // ...\n Diag(TRange.getBegin(), diag::warn_cast_align) << Op->getType() << T << static_cast<unsigned>(SrcAlign.getQuantity()) << static_cast<unsigned>(DestAlign.getQuantity()) << TRange << Op->getSourceRange();"}},
[l]={
["clang/test/Sema/warn-cast-align.c"]={"clang/test/Sema/warn-cast-align.c:6:14: warning: cast from \'char *\' to \'short *\' increases required alignment from 1 to 2 [-Wcast-align]","clang/test/Sema/warn-cast-align.c:7:14: warning: cast from \'char *\' to \'int *\' increases required alignment from 1 to 4 [-Wcast-align]","clang/test/Sema/warn-cast-align.c:35:17: warning: cast from \'char *\' to \'struct A *\' increases required alignment from 1 to 16 [-Wcast-align]","clang/test/Sema/warn-cast-align.c:76:18: warning: cast from \'int *\' to \'void **\' increases required alignment from 4 to 8 [-Wcast-align]"}
}
},
["warn_cast_calling_conv"]={
[j]={"cast-calling-convention"},
[k]="cast-calling-convention",
[g]="warn_cast_calling_conv",
[b]="cast between incompatible calling conventions \'%0\' and \'%1\'; calls through this pointer may abort at runtime",
[c]="cast between incompatible calling conventions \'A\' and \'B\'; calls through this pointer may abort at runtime",
[d]=m,
[e]="cast between incompatible calling conventions \'(.*?)\' and \'(.*?)\'; calls through this pointer may abort at runtime",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-calling\\-convention[^\\]]*\\]",
[h]=n,
[a]={"9f49733c65b0",1462914003,"Add -Wcast-calling-convention to warn when casting away calling conventions","Add -Wcast-calling-convention to warn when casting away calling conventions\n\nSummary:\nThis only warns on casts of the address of a function defined in the\ncurrent TU. In this case, the fix is likely to be local and the warning\nuseful.\n\nHere are some things we could experiment with in the future:\n- Fire on declarations as well as definitions\n- Limit the warning to non-void function prototypes\n- Limit the warning to mismatches of caller and callee cleanup CCs\n\nThis warning is currently off by default while we study its usefulness.\n\nReviewers: thakis, rtrieu\n\nSubscribers: cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D17348\n\nllvm-svn: 269116"},
[i]={{mb,2146,"/// Diagnose casts that change the calling convention of a pointer to a function\n/// defined in the current TU.\nstatic void DiagnoseCallingConvCast(Sema &Self, const ExprResult &SrcExpr, QualType DstType, SourceRange OpRange) {\n // ...\n Self.Diag(OpRange.getBegin(), diag::warn_cast_calling_conv) << SrcCCName << DstCCName << OpRange;"},{mb,2152,"/// Diagnose casts that change the calling convention of a pointer to a function\n/// defined in the current TU.\nstatic void DiagnoseCallingConvCast(Sema &Self, const ExprResult &SrcExpr, QualType DstType, SourceRange OpRange) {\n // ...\n if (Self.Diags.isIgnored(diag::warn_cast_calling_conv, OpRange.getBegin()))"}},
[l]={
["clang/test/Sema/callingconv-cast.c"]={"clang/test/Sema/callingconv-cast.c:34:17: warning: cast between incompatible calling conventions \'cdecl\' and \'stdcall\'; calls through this pointer may abort at runtime [-Wcast-calling-convention]","clang/test/Sema/callingconv-cast.c:37:25: warning: cast between incompatible calling conventions \'cdecl\' and \'stdcall\'; calls through this pointer may abort at runtime [-Wcast-calling-convention]","clang/test/Sema/callingconv-cast.c:41:14: warning: cast between incompatible calling conventions \'cdecl\' and \'stdcall\'; calls through this pointer may abort at runtime [-Wcast-calling-convention]","clang/test/Sema/callingconv-cast.c:47:14: warning: cast between incompatible calling conventions \'cdecl\' and \'stdcall\'; calls through this pointer may abort at runtime [-Wcast-calling-convention]","clang/test/Sema/callingconv-cast.c:58:17: warning: cast between incompatible calling conventions \'cdecl\' and \'stdcall\'; calls through this pointer may abort at runtime [-Wcast-calling-convention]","clang/test/Sema/callingconv-cast.c:60:17: warning: cast between incompatible calling conventions \'cdecl\' and \'stdcall\'; calls through this pointer may abort at runtime [-Wcast-calling-convention]"}
}
},
["warn_cast_function_type"]={
[j]={"cast-function-type"},
[k]="cast-function-type",
[g]={{nil,w,"warn_cast_function_type"}},
[b]={{nil,w,"cast %diff{from $ to $ |}0,1converts to incompatible function type"}},
[c]={{nil,w,{"cast ",{"from A to B ",r},"converts to incompatible function type"}}},
[d]=m,
[e]="cast (?:from (.*?) to (.*?) |)converts to incompatible function type",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-function\\-type[^\\]]*\\]",
[h]={{nil,w,n}},
[a]={hb,1590001902,ib,kb},
[i]={{mb,1099,"static unsigned int checkCastFunctionType(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n const unsigned int DiagList[] = {diag::warn_cast_function_type_strict, diag::warn_cast_function_type};"}},
[l]={
["clang/test/SemaCXX/warn-cast-function-type.cpp"]={"clang/test/SemaCXX/warn-cast-function-type.cpp:32:7: warning: cast from \'int (*)(long)\' to \'f2 *\' (aka \'int (*)(void *)\') converts to incompatible function type [-Wcast-function-type]","clang/test/SemaCXX/warn-cast-function-type.cpp:33:7: warning: cast from \'int (*)(long)\' to \'f2 *\' (aka \'int (*)(void *)\') converts to incompatible function type [-Wcast-function-type]","clang/test/SemaCXX/warn-cast-function-type.cpp:35:7: warning: cast from \'int (*)(long)\' to \'f4 *\' (aka \'void (*)(...)\') converts to incompatible function type [-Wcast-function-type]","clang/test/SemaCXX/warn-cast-function-type.cpp:37:7: warning: cast from \'int (*)(long)\' to \'f6 *\' (aka \'int (*)(long, int)\') converts to incompatible function type [-Wcast-function-type]","clang/test/SemaCXX/warn-cast-function-type.cpp:40:11: warning: cast from \'void (S::*)(int *)\' to \'mf\' (aka \'void (S::*)(int)\') converts to incompatible function type [-Wcast-function-type]","clang/test/SemaCXX/warn-cast-function-type.cpp:42:11: warning: cast from \'int (long)\' to \'f8\' (aka \'int (&)(long, int)\') converts to incompatible function type [-Wcast-function-type]","clang/test/SemaCXX/warn-cast-function-type.cpp:46:7: warning: cast from \'int (^)(long)\' to \'f6 *\' (aka \'int (*)(long, int)\') converts to incompatible function type [-Wcast-function-type]"}
}
},
["warn_cast_function_type_strict"]={
[j]={"cast-function-type","cast-function-type-strict"},
[k]="cast-function-type-strict",
[g]={{nil,v,"warn_cast_function_type_strict"}},
[b]={{nil,v,"cast %diff{from $ to $ |}0,1converts to incompatible function type"}},
[c]={{nil,v,{"cast ",{"from A to B ",r},"converts to incompatible function type"}}},
[d]=m,
[e]="cast (?:from (.*?) to (.*?) |)converts to incompatible function type",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-function\\-type\\-strict[^\\]]*\\]",
[h]={{nil,v,n}},
[a]={sb,1625925174,rb,vb},
[i]={{mb,1098,"static unsigned int checkCastFunctionType(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n const unsigned int DiagList[] = {diag::warn_cast_function_type_strict, diag::warn_cast_function_type};"},{mb,1130,"static unsigned int checkCastFunctionType(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n if (DiagID == diag::warn_cast_function_type_strict)"}}
},
["warn_cast_nonnull_to_bool"]={
[j]={"address","bool-conversion","bool-conversions",Bb,Cb,"pointer-bool-conversion"},
[k]="pointer-bool-conversion",
[g]="warn_cast_nonnull_to_bool",
[b]="nonnull %select{function call|parameter}0 \'%1\' will evaluate to \'true\' on first encounter",
[c]={{nil,nil,{"nonnull ",{"function call","parameter"}," \'B\' will evaluate to \'true\' on first encounter"}}},
[d]=m,
[e]="nonnull (?:function call|parameter) \'(.*?)\' will evaluate to \'true\' on first encounter",
[f]=" \\[(?:\\-Werror,)?\\-Wpointer\\-bool\\-conversion[^\\]]*\\]",
[h]=ac,
[a]={"4c8cb14c1ab0",1414090810,"patch to issue warning on comparing parameters with","patch to issue warning on comparing parameters with\nnonnull attribute when comparison is always\ntrue/false. Patch by Steven Wu with few fixes and minor\nrefactoring and adding tests by me. rdar://18712242\n\nllvm-svn: 220496"},
[i]={{u,15490,"/// Diagnose pointers that are always non-null.\n/// \\param E the expression containing the pointer\n/// \\param NullKind NPCK_NotNull if E is a cast to bool, otherwise, E is\n/// compared to a null pointer\n/// \\param IsEqual True when the comparison is equal to a null pointer\n/// \\param Range Extra SourceRange to highlight in the diagnostic\nvoid Sema::DiagnoseAlwaysNonNullPointer(Expr *E, Expr::NullPointerConstantKind NullKind, bool IsEqual, SourceRange Range) {\n // ...\n auto ComplainAboutNonnullParamOrCall = [&](const Attr *NonnullAttr) {\n // ...\n unsigned DiagID = IsCompare ? diag::warn_nonnull_expr_compare : diag::warn_cast_nonnull_to_bool;"}},
[l]={
["clang/test/Sema/nonnull.c"]={"clang/test/Sema/nonnull.c:139:8: warning: nonnull parameter \'pointer\' will evaluate to \'true\' on first encounter [-Wpointer-bool-conversion]","clang/test/Sema/nonnull.c:149:7: warning: nonnull parameter \'p\' will evaluate to \'true\' on first encounter [-Wpointer-bool-conversion]","clang/test/Sema/nonnull.c:168:7: warning: nonnull function call \'returns_nonnull_whee()\' will evaluate to \'true\' on first encounter [-Wpointer-bool-conversion]","clang/test/Sema/nonnull.c:169:8: warning: nonnull function call \'returns_nonnull_whee()\' will evaluate to \'true\' on first encounter [-Wpointer-bool-conversion]","clang/test/Sema/nonnull.c:171:20: warning: nonnull function call \'returns_nonnull_whee()\' will evaluate to \'true\' on first encounter [-Wpointer-bool-conversion]","clang/test/Sema/nonnull.c:172:16: warning: nonnull function call \'returns_nonnull_whee()\' will evaluate to \'true\' on first encounter [-Wpointer-bool-conversion]"}
}
},
["warn_cast_pointer_from_sel"]={
[j]={P,T,"cast-of-sel-type",cb},
[k]="cast-of-sel-type",
[g]="warn_cast_pointer_from_sel",
[b]="cast of type %0 to %1 is deprecated; use sel_getName instead",
[c]="cast of type A to B is deprecated; use sel_getName instead",
[d]=m,
[e]="cast of type (.*?) to (.*?) is deprecated; use sel_getName instead",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-of\\-sel\\-type[^\\]]*\\]",
[h]=n,
[a]={"5ad9659688e8",1345142027,"objective-C: deprecate casts of ObjC\'s SEL","objective-C: deprecate casts of ObjC\'s SEL\nexpressions except to void, void * and their\nqualified versions. // rdar://12107381\n\nllvm-svn: 162036"},
[i]={{mb,2097,"static void DiagnoseCastOfObjCSEL(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n if (const PointerType *SrcPtrTy = SrcType->getAs<PointerType>())\n if (SrcPtrTy->isObjCSelType()) {\n // ...\n if (!DT.getUnqualifiedType()->isVoidType())\n Self.Diag(SrcExpr.get()->getExprLoc(), diag::warn_cast_pointer_from_sel) << SrcType << DestType << SrcExpr.get()->getSourceRange();"}},
[l]={
["clang/test/SemaObjC/warn-cast-of-sel-expr.m"]={"clang/test/SemaObjC/warn-cast-of-sel-expr.m:10:9: warning: cast of type \'SEL\' to \'char *\' is deprecated; use sel_getName instead [-Wcast-of-sel-type]","clang/test/SemaObjC/warn-cast-of-sel-expr.m:12:15: warning: cast of type \'SEL\' to \'const char *\' is deprecated; use sel_getName instead [-Wcast-of-sel-type]"}
}
},
["warn_cast_qual"]={
[j]={"cast-qual"},
[k]="cast-qual",
[g]="warn_cast_qual",
[b]="cast from %0 to %1 drops %select{const and volatile qualifiers|const qualifier|volatile qualifier}2",
[c]={{nil,nil,{"cast from A to B drops ",{"const and volatile qualifiers","const qualifier","volatile qualifier"}}}},
[d]=m,
[e]="cast from (.*?) to (.*?) drops (?:const and volatile qualifiers|const qualifier|volatile qualifier)",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-qual[^\\]]*\\]",
[h]=n,
[a]={"d5178014938d",1416603790,"Implement -Wcast-qual, fixing #13772.","Implement -Wcast-qual, fixing #13772.\n\nMany thanks to dblaikie for his advices and suggestions!\n\nllvm-svn: 222568"},
[i]={{mb,3328,"/// DiagnoseCastQual - Warn whenever casts discards a qualifiers, be it either\n/// const, volatile or both.\nstatic void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n // This is a variant of int **x; const int **y = (const int **)x;\n if (qualifiers == -1)\n // ...\n else\n Self.Diag(SrcExpr.get()->getBeginLoc(), diag::warn_cast_qual) << TheOffendingSrcType << TheOffendingDestType << qualifiers;"}},
[l]={
["clang/test/SemaCXX/warn-cast-qual.cpp"]={"clang/test/SemaCXX/warn-cast-qual.cpp:19:21: warning: cast from \'const void *\' to \'void *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:21:21: warning: cast from \'const char *\' to \'char *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:30:20: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:31:26: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:32:20: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:33:28: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:34:34: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:35:26: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:36:40: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:45:20: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:46:29: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:47:20: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:48:28: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:49:37: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:50:29: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:51:46: warning: cast from \'volatile int\' to \'int &\' drops volatile qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:60:20: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:61:35: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:62:20: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:63:28: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:64:43: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:65:35: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:66:58: warning: cast from \'const volatile int\' to \'int &\' drops const and volatile qualifiers [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:73:22: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:74:31: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:79:43: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:87:22: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:88:31: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:93:43: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:106:9: warning: cast from \'const C\' to \'C &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:107:9: warning: cast from \'const C\' to \'C &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:109:9: warning: cast from \'const C *\' to \'C *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:110:9: warning: cast from \'const C *\' to \'C *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:125:12: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:128:13: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:134:12: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:135:12: warning: cast from \'const int\' to \'int &\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:137:13: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:138:13: warning: cast from \'const int *\' to \'int *\' drops const qualifier [-Wcast-qual]"}
}
},
["warn_cast_qual2"]={
[j]={"cast-qual"},
[k]="cast-qual",
[g]="warn_cast_qual2",
[b]="cast from %0 to %1 must have all intermediate pointers const qualified to be safe",
[c]="cast from A to B must have all intermediate pointers const qualified to be safe",
[d]=m,
[e]="cast from (.*?) to (.*?) must have all intermediate pointers const qualified to be safe",
[f]=" \\[(?:\\-Werror,)?\\-Wcast\\-qual[^\\]]*\\]",
[h]=n,
[a]={"d5178014938d",1416603790,"Implement -Wcast-qual, fixing #13772.","Implement -Wcast-qual, fixing #13772.\n\nMany thanks to dblaikie for his advices and suggestions!\n\nllvm-svn: 222568"},
[i]={{mb,3325,"/// DiagnoseCastQual - Warn whenever casts discards a qualifiers, be it either\n/// const, volatile or both.\nstatic void DiagnoseCastQual(Sema &Self, const ExprResult &SrcExpr, QualType DestType) {\n // ...\n // This is a variant of int **x; const int **y = (const int **)x;\n if (qualifiers == -1)\n Self.Diag(SrcExpr.get()->getBeginLoc(), diag::warn_cast_qual2) << SrcType << DestType;"}},
[l]={
["clang/test/SemaCXX/warn-cast-qual.cpp"]={"clang/test/SemaCXX/warn-cast-qual.cpp:79:34: warning: cast from \'int **\' to \'const int **\' must have all intermediate pointers const qualified to be safe [-Wcast-qual]","clang/test/SemaCXX/warn-cast-qual.cpp:93:34: warning: cast from \'int *\' to \'const int *&\' must have all intermediate pointers const qualified to be safe [-Wcast-qual]"}
}
},
["warn_category_method_impl_match"]={
[j]={"objc-protocol-method-implementation"},
[k]="objc-protocol-method-implementation",
[g]="warn_category_method_impl_match",
[b]="category is implementing a method which will also be implemented by its primary class",
[c]="category is implementing a method which will also be implemented by its primary class",
[d]=m,
[e]="category is implementing a method which will also be implemented by its primary class",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-protocol\\-method\\-implementation[^\\]]*\\]",
[h]=n,
[a]={"9f8b19e9aea9",1311895190,"objective-c: warn if implementation of a method in category","objective-c: warn if implementation of a method in category\nmasks an existing method in its primary class, class extensions,\nand primary class\'s non-optional protocol methods; as primary\nclass, or one of its subclass\'s will implement this method.\nThis warning has potential of being noisy so it has its own\ngroup. // rdar://7020493\n\nllvm-svn: 136426"},
[i]={{W,2665,"/// WarnExactTypedMethods - This routine issues a warning if method\n/// implementation declaration matches exactly that of its declaration.\nvoid Sema::WarnExactTypedMethods(ObjCMethodDecl *ImpMethodDecl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl) {\n // ...\n if (match) {\n Diag(ImpMethodDecl->getLocation(), diag::warn_category_method_impl_match);"}},
[l]={
["clang/test/SemaObjC/protocol-implementing-class-methods.m"]={"clang/test/SemaObjC/protocol-implementing-class-methods.m:24:1: warning: category is implementing a method which will also be implemented by its primary class [-Wobjc-protocol-method-implementation]","clang/test/SemaObjC/protocol-implementing-class-methods.m:27:1: warning: category is implementing a method which will also be implemented by its primary class [-Wobjc-protocol-method-implementation]","clang/test/SemaObjC/protocol-implementing-class-methods.m:26:1: warning: category is implementing a method which will also be implemented by its primary class [-Wobjc-protocol-method-implementation]"}
}
},
["warn_cconv_knr"]={
[j]={"missing-prototype-for-cc"},
[k]="missing-prototype-for-cc",
[g]="warn_cconv_knr",
[b]="function with no prototype cannot use the %0 calling convention",
[c]="function with no prototype cannot use the A calling convention",
[d]=m,
[e]="function with no prototype cannot use the (.*?) calling convention",
[f]=" \\[(?:\\-Werror,)?\\-Wmissing\\-prototype\\-for\\-cc[^\\]]*\\]",
[h]=n,
[a]={"d191063c6c50",1411168032,"Follow-up to r214408: Warn on other callee-cleanup functions without prototype too.","Follow-up to r214408: Warn on other callee-cleanup functions without prototype too.\n\nAccording to lore, we used to verifier-fail on:\n\n void __thiscall f();\n int main() { f(1); }\n\nSo that\'s fixed now. System headers use prototype-less __stdcall functions,\nso make that a warning that\'s DefaultError -- then it fires on regular code\nbut is suppressed in system headers.\n\nSince it\'s used in system headers, we have codegen tests for this; massage\nthem slightly so that they still compile.\n\nllvm-svn: 218166"},
[i]={{H,10321,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n // ...\n if (!getLangOpts().CPlusPlus) {\n // ...\n if (isa<FunctionNoProtoType>(FT) && !D.isFunctionDefinition()) {\n // ...\n if (!supportsVariadicCall(CC)) {\n // ...\n int DiagID = CC == CC_X86StdCall ? diag::warn_cconv_knr : diag::err_cconv_knr;"}},
[l]={
["clang/test/Sema/decl-microsoft-call-conv.c"]={"clang/test/Sema/decl-microsoft-call-conv.c:23:16: warning: function with no prototype cannot use the stdcall calling convention [-Wmissing-prototype-for-cc]"}
}
},
["warn_cconv_unsupported"]={
[j]={x,q},
[k]=q,
[g]={{nil,B,"warn_cconv_unsupported"}},
[b]={{nil,B,"%0 calling convention is not supported %select{for this target|on variadic function|on constructor/destructor|on builtin function}1"}},
[c]={{nil,B,{"A calling convention is not supported ",{"for this target","on variadic function","on constructor/destructor","on builtin function"}}}},
[d]=m,
[e]="(.*?) calling convention is not supported (?:for this target|on variadic function|on constructor\\/destructor|on builtin function)",
[f]=y,
[h]={{nil,B,n}},
[a]={"85d667fcb6f3",1563396086,"Renamed and changed the wording of warn_cconv_ignored","Renamed and changed the wording of warn_cconv_ignored\n\nAs discussed in D64780 the wording of this warning message is being\nchanged to say \'is not supported\' instead of \'ignored\', and the\ndiag ID itself is being changed to warn_cconv_not_supported.\n\nllvm-svn: 366368"},
[i]={{H,3801,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'. Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n // ...\n if (OldTypeInfo.getCC() != NewTypeInfo.getCC()) {\n // ...\n if (!NewCCExplicit) {\n // ...\n } else if (Old->getBuiltinID()) {\n // ...\n Diag(New->getLocation(), diag::warn_cconv_unsupported) << FunctionType::getNameForCallConv(NewTypeInfo.getCC()) << (int)CallingConventionIgnoredReason::BuiltinFunction;"},{o,5453,"bool Sema::CheckCallingConvAttr(const ParsedAttr &Attrs, CallingConv &CC, const FunctionDecl *FD) {\n // ...\n case TargetInfo::CCCR_Warning: {\n Diag(Attrs.getLoc(), diag::warn_cconv_unsupported) << Attrs << (int)CallingConventionIgnoredReason::ForThisTarget;"},{lb,7994,"/// Process an individual function attribute. Returns true to\n/// indicate that the attribute was handled, false if it wasn\'t.\nstatic bool handleFunctionTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n // ...\n // Diagnose use of variadic functions with calling conventions that\n // don\'t support them (e.g. because they\'re callee-cleanup).\n // We delay warning about this on unprototyped function declarations\n // until after redeclaration checking, just in case we pick up a\n // prototype that way. And apparently we also \"delay\" warning about\n // unprototyped function types in general, despite not necessarily having\n // much ability to diagnose it later.\n if (!supportsVariadicCall(CC)) {\n // ...\n if (FnP && FnP->isVariadic()) {\n // stdcall and fastcall are ignored with a warning for GCC and MS\n // compatibility.\n if (CC == CC_X86StdCall || CC == CC_X86FastCall)\n return S.Diag(attr.getLoc(), diag::warn_cconv_unsupported) << FunctionType::getNameForCallConv(CC) << (int)Sema::CallingConventionIgnoredReason::VariadicFunction;"},{lb,8060,"void Sema::adjustMemberFunctionCC(QualType &T, bool IsStatic, bool IsCtorOrDtor, SourceLocation Loc) {\n // ...\n // MS compiler ignores explicit calling convention attributes on structors. We\n // should do the same.\n if (Context.getTargetInfo().getCXXABI().isMicrosoft() && IsCtorOrDtor) {\n // Issue a warning on ignored calling convention -- except of __stdcall.\n // Again, this is what MS compiler does.\n if (CurCC != CC_X86StdCall)\n Diag(Loc, diag::warn_cconv_unsupported) << FunctionType::getNameForCallConv(CurCC) << (int)Sema::CallingConventionIgnoredReason::ConstructorDestructor;"}},
[l]={
["clang/test/Sema/stdcall-fastcall-x64.c"]={"clang/test/Sema/stdcall-fastcall-x64.c:8:21: warning: \'stdcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:8:30: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:9:21: warning: \'stdcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:10:21: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:13:51: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:14:51: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:14:61: warning: \'stdcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:15:51: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:16:51: warning: \'stdcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:17:51: warning: \'stdcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:17:60: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:18:58: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:19:58: warning: \'stdcall\' calling convention is not supported for this target [-Wignored-attributes]","clang/test/Sema/stdcall-fastcall-x64.c:20:63: warning: \'fastcall\' calling convention is not supported for this target [-Wignored-attributes]"}
}
},
["warn_cdtor_function_try_handler_mem_expr"]={
[j]={"exceptions"},
[k]="exceptions",
[g]="warn_cdtor_function_try_handler_mem_expr",
[b]="cannot refer to a non-static member from the handler of a %select{constructor|destructor}0 function try block",
[c]={{nil,nil,{"cannot refer to a non-static member from the handler of a ",{"constructor","destructor"}," function try block"}}},
[d]=m,
[e]="cannot refer to a non\\-static member from the handler of a (?:constructor|destructor) function try block",
[f]=" \\[(?:\\-Werror,)?\\-Wexceptions[^\\]]*\\]",
[h]=n,
[a]={"6924dcdf6f73",1441118964,"Add a new frontend warning for referencing members from the handler of a constructor or destructor f...","Add a new frontend warning for referencing members from the handler of a constructor or destructor function-try-block, which is UB in C++.\n\nThis corresponds to the CERT secure coding rule ERR53-CPP.\n\nllvm-svn: 246548"},
[i]={{"clang/lib/Sema/SemaExprMember.cpp",995,"ExprResult Sema::BuildMemberReferenceExpr(Expr *BaseExpr, QualType BaseExprType, SourceLocation OpLoc, bool IsArrow, const CXXScopeSpec &SS, SourceLocation TemplateKWLoc, NamedDecl *FirstQualifierInScope, LookupResult &R, const TemplateArgumentListInfo *TemplateArgs, const Scope *S, bool SuppressQualifierCheck, ActOnMemberAccessExtraArgs *ExtraArgs) {\n // ...\n if (S && BaseExpr && FD && (isa<CXXDestructorDecl>(FD) || isa<CXXConstructorDecl>(FD)) && isa<CXXThisExpr>(BaseExpr->IgnoreImpCasts()) && IsInFnTryBlockHandler(S))\n Diag(MemberLoc, diag::warn_cdtor_function_try_handler_mem_expr) << isa<CXXDestructorDecl>(FD);"}},
[l]={
["clang/test/SemaCXX/cdtor-fn-try-block.cpp"]={"clang/test/SemaCXX/cdtor-fn-try-block.cpp:10:5: warning: cannot refer to a non-static member from the handler of a constructor function try block [-Wexceptions]","clang/test/SemaCXX/cdtor-fn-try-block.cpp:11:5: warning: cannot refer to a non-static member from the handler of a constructor function try block [-Wexceptions]","clang/test/SemaCXX/cdtor-fn-try-block.cpp:27:5: warning: cannot refer to a non-static member from the handler of a constructor function try block [-Wexceptions]","clang/test/SemaCXX/cdtor-fn-try-block.cpp:28:5: warning: cannot refer to a non-static member from the handler of a constructor function try block [-Wexceptions]","clang/test/SemaCXX/cdtor-fn-try-block.cpp:52:5: warning: cannot refer to a non-static member from the handler of a destructor function try block [-Wexceptions]","clang/test/SemaCXX/cdtor-fn-try-block.cpp:53:5: warning: cannot refer to a non-static member from the handler of a destructor function try block [-Wexceptions]"}
}
},
["warn_cfstring_truncated"]={
[j]={"CFString-literal"},
[k]="CFString-literal",
[g]="warn_cfstring_truncated",
[b]="input conversion stopped due to an input byte that does not belong to the input codeset UTF-8",
[c]="input conversion stopped due to an input byte that does not belong to the input codeset UTF-8",
[d]=m,
[e]="input conversion stopped due to an input byte that does not belong to the input codeset UTF\\-8",
[f]=" \\[(?:\\-Werror,)?\\-WCFString\\-literal[^\\]]*\\]",
[h]=n,
[a]={"56603ef7b279",1283888293,"Have Sema check for validity of CGString literal","Have Sema check for validity of CGString literal\ninstead of asserting in IRGen. Fixes radar 8390459.\n\nllvm-svn: 113253"},
[i]={{u,7995,"/// CheckObjCString - Checks that the argument to the builtin\n/// CFString constructor is correct\n/// Note: It might also make sense to do the UTF-16 conversion here (would\n/// simplify the backend).\nbool Sema::CheckObjCString(Expr *Arg) {\n // ...\n if (Literal->containsNonAsciiOrNull()) {\n // ...\n // Check for conversion failure.\n if (Result != llvm::conversionOK)\n Diag(Arg->getBeginLoc(), diag::warn_cfstring_truncated) << Arg->getSourceRange();"}},
[l]={
["clang/test/CodeGenObjC/illegal-UTF8.m"]={"clang/test/CodeGenObjC/illegal-UTF8.m:6:16: warning: input conversion stopped due to an input byte that does not belong to the input codeset UTF-8 [-WCFString-literal]"}
}
},
["warn_char_constant_too_large"]={
[g]="warn_char_constant_too_large",
[b]="character constant too long for its type",
[c]="character constant too long for its type",
[d]=m,
[e]="character constant too long for its type",
[f]=jb,
[h]=A,
[a]={K,1236199783,J,I},
[i]={{Dc,1827,"/// \\verbatim\n/// user-defined-character-literal: [C++11 lex.ext]\n/// character-literal ud-suffix\n/// ud-suffix:\n/// identifier\n/// character-literal: [C++11 lex.ccon]\n/// \' c-char-sequence \'\n/// u\' c-char-sequence \'\n/// U\' c-char-sequence \'\n/// L\' c-char-sequence \'\n/// u8\' c-char-sequence \' [C++1z lex.ccon]\n/// c-char-sequence:\n/// c-char\n/// c-char-sequence c-char\n/// c-char:\n/// any member of the source character set except the single-quote \',\n/// backslash \\, or new-line character\n/// escape-sequence\n/// universal-character-name\n/// escape-sequence:\n/// simple-escape-sequence\n/// octal-escape-sequence\n/// hexadecimal-escape-sequence\n/// simple-escape-sequence:\n/// one of \\\' \\\" \\? \\\\ \\a \\b \\f \\n \\r \\t \\v\n/// octal-escape-sequence:\n/// \\ octal-digit\n/// \\ octal-digit octal-digit\n/// \\ octal-digit octal-digit octal-digit\n/// hexadecimal-escape-sequence:\n/// \\x hexadecimal-digit\n/// hexadecimal-escape-sequence hexadecimal-digit\n/// universal-character-name: [C++11 lex.charset]\n/// \\u hex-quad\n/// \\U hex-quad hex-quad\n/// hex-quad:\n/// hex-digit hex-digit hex-digit hex-digit\n/// \\endverbatim\n///\nCharLiteralParser::CharLiteralParser(const char *begin, const char *end, SourceLocation Loc, Preprocessor &PP, tok::TokenKind kind) {\n // ...\n if (!HadError && multi_char_too_long) {\n PP.Diag(Loc, diag::warn_char_constant_too_large);"}},
[l]={
["clang/test/Preprocessor/if_warning.c"]={"clang/test/Preprocessor/if_warning.c:32:5: warning: character constant too long for its type"}
}
},
["warn_class_method_not_found"]={
[j]={"objc-method-access"},
[k]="objc-method-access",
[g]="warn_class_method_not_found",
[b]="class method %objcclass0 not found (return type defaults to \'id\')",
[c]="class method A not found (return type defaults to \'id\')",
[d]=m,
[e]="class method (.*?) not found \\(return type defaults to \'id\'\\)",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-method\\-access[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{ec,1745,"bool Sema::CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType, MultiExprArg Args, Selector Sel, ArrayRef<SourceLocation> SelectorLocs, ObjCMethodDecl *Method, bool isClassMessage, bool isSuperMessage, SourceLocation lbrac, SourceLocation rbrac, SourceRange RecRange, QualType &ReturnType, ExprValueKind &VK) {\n // ...\n if (!Method) {\n // ...\n if (getLangOpts().ObjCAutoRefCount)\n // ...\n else\n DiagID = isClassMessage ? diag::warn_class_method_not_found : diag::warn_inst_method_not_found;"}},
[l]={
["clang/test/SemaObjC/method-lookup.m"]={"clang/test/SemaObjC/method-lookup.m:25:54: warning: class method \'+completionItems\' not found (return type defaults to \'id\') [-Wobjc-method-access]"}
}
},
["warn_class_method_not_found_with_typo"]={
[j]={"objc-method-access"},
[k]="objc-method-access",
[g]="warn_class_method_not_found_with_typo",
[b]="class method %objcclass0 not found (return type defaults to \'id\'); did you mean %objcclass2?",
[c]="class method A not found (return type defaults to \'id\'); did you mean C?",
[d]=m,
[e]="class method (.*?) not found \\(return type defaults to \'id\'\\); did you mean (.*?)\\?",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-method\\-access[^\\]]*\\]",
[h]=n,
[a]={"4cc5552b9b94",1371569496,"Objective-C [qoi]: privide typo correction for selectors","Objective-C [qoi]: privide typo correction for selectors\nin addition of receiver having static type, but also when\nreceiver has dynamic type (of \'id\' variety) as well as when\nreceiver is of \'Class\' type vareity. // rdar://7853549\n\nllvm-svn: 184195"},
[i]={{ec,1753,"bool Sema::CheckMessageArgumentTypes(const Expr *Receiver, QualType ReceiverType, MultiExprArg Args, Selector Sel, ArrayRef<SourceLocation> SelectorLocs, ObjCMethodDecl *Method, bool isClassMessage, bool isSuperMessage, SourceLocation lbrac, SourceLocation rbrac, SourceRange RecRange, QualType &ReturnType, ExprValueKind &VK) {\n // ...\n if (!Method) {\n // ...\n if (!getLangOpts().DebuggerSupport) {\n // ...\n if (OMD && !OMD->isInvalidDecl()) {\n if (getLangOpts().ObjCAutoRefCount)\n // ...\n else\n DiagID = isClassMessage ? diag::warn_class_method_not_found_with_typo : diag::warn_instance_method_not_found_with_typo;"}},
[l]={
["clang/test/SemaObjC/call-super-2.m"]={"clang/test/SemaObjC/call-super-2.m:38:26: warning: class method \'+class_func0\' not found (return type defaults to \'id\'); did you mean \'+class_func5\'? [-Wobjc-method-access]"}
}
},
["warn_clause_expected_string"]={
[j]={"ignored-pragmas","pragmas"},
[k]="ignored-pragmas",
[g]={{nil,v,"warn_clause_expected_string"}},
[b]={{nil,v,"expected string literal in \'clause %0\' - ignoring"}},
[c]={{nil,v,"expected string literal in \'clause A\' - ignoring"}},
[d]=m,
[e]="expected string literal in \'clause (.*?)\' \\- ignoring",
[f]=" \\[(?:\\-Werror,)?\\-Wignored\\-pragmas[^\\]]*\\]",
[h]={{nil,v,db}},
[a]={"9d90cf2fca44",1668751380,"[OPENMP5.1] Initial support for message clause.","[OPENMP5.1] Initial support for message clause."},
[i]={{"clang/lib/Sema/SemaOpenMP.cpp",16939,"OMPClause *Sema::ActOnOpenMPMessageClause(Expr *ME, SourceLocation StartLoc, SourceLocation LParenLoc, SourceLocation EndLoc) {\n // ...\n if (!isa<StringLiteral>(ME)) {\n Diag(ME->getBeginLoc(), diag::warn_clause_expected_string) << getOpenMPClauseName(OMPC_message);"}},
[l]={
["clang/test/OpenMP/error_message.cpp"]={"clang/test/OpenMP/error_message.cpp:114:27: warning: expected string literal in \'clause message\' - ignoring [-Wignored-pragmas]"}
}
},
["warn_cleanup_ext"]={
[j]={kc},
[k]=kc,
[g]="warn_cleanup_ext",
[b]="GCC does not allow the \'cleanup\' attribute argument to be anything other than a simple identifier",
[c]="GCC does not allow the \'cleanup\' attribute argument to be anything other than a simple identifier",
[d]=m,
[e]="GCC does not allow the \'cleanup\' attribute argument to be anything other than a simple identifier",
[f]=" \\[(?:\\-Werror,)?\\-Wgcc\\-compat[^\\]]*\\]",
[h]=n,
[a]={"c12aaff2cbe5",1378863461,"The cleanup attribute no longer uses an unresolved, simple identifier as its argument. Instead, it ...","The cleanup attribute no longer uses an unresolved, simple identifier as its argument. Instead, it takes an expression that is fully resolved.\n\nllvm-svn: 190476"},
[i]={{o,3706,"static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n // gcc only allows for simple identifiers. Since we support more than gcc, we\n // will warn the user.\n if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {\n if (DRE->hasQualifier())\n S.Diag(Loc, diag::warn_cleanup_ext);"},{o,3716,"static void handleCleanupAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n // ...\n // gcc only allows for simple identifiers. Since we support more than gcc, we\n // will warn the user.\n if (auto *DRE = dyn_cast<DeclRefExpr>(E)) {\n // ...\n } else if (auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {\n if (ULE->hasExplicitTemplateArgs())\n S.Diag(Loc, diag::warn_cleanup_ext);"}},
[l]={
["clang/test/CodeGenCXX/attr-cleanup.cpp"]={"clang/test/CodeGenCXX/attr-cleanup.cpp:9:35: warning: GCC does not allow the \'cleanup\' attribute argument to be anything other than a simple identifier [-Wgcc-compat]"}
}
},
["warn_cmse_nonsecure_union"]={
[j]={"cmse-union-leak"},
[k]="cmse-union-leak",
[g]={{nil,t,"warn_cmse_nonsecure_union"}},
[b]={{nil,t,"passing union across security boundary via %select{parameter %1|return value}0 may leak information"}},
[c]={{nil,t,{"passing union across security boundary via ",{"parameter B","return value"}," may leak information"}}},
[d]=m,
[e]="passing union across security boundary via (?:parameter (.*?)|return value) may leak information",
[f]=" \\[(?:\\-Werror,)?\\-Wcmse\\-union\\-leak[^\\]]*\\]",
[h]={{nil,t,n}},
[a]={"931fcd3ba011",1576908663,"[WebAssembly] Improve clang diagnostics for wasm attributes","[WebAssembly] Improve clang diagnostics for wasm attributes\n\nThis patch addresses the review comments on r352930:\n\n - Removes redundant diagnostic checking code\n - Removes errnoneous use of diag::err_alias_is_definition, which\n turned out to be ineffective anyway since functions can be defined later\n in the translation unit and avoid detection.\n - Adds a test for various invalid cases for import_name and import_module.\n\nDifferential Revision: https://reviews.llvm.org/D59520"},
[i]={{G,7655,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy. The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n // ...\n // Warn for unions passing across security boundary (CMSE).\n if (FuncT != nullptr && FuncT->getCmseNSCallAttr()) {\n for (unsigned i = 0, e = Args.size(); i != e; i++) {\n if (const auto *RT = dyn_cast<RecordType>(Args[i]->getType().getCanonicalType())) {\n if (RT->getDecl()->isOrContainsUnion())\n Diag(Args[i]->getBeginLoc(), diag::warn_cmse_nonsecure_union) << 0 << i;"},{X,3970,"StmtResult Sema::BuildReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp, bool AllowRecovery) {\n // ...\n if (const FunctionDecl *FD = getCurFunctionDecl()) {\n // ...\n if (FD->hasAttr<CmseNSEntryAttr>() && RetValExp) {\n if (const auto *RT = dyn_cast<RecordType>(FnRetType.getCanonicalType())) {\n if (RT->getDecl()->isOrContainsUnion())\n Diag(RetValExp->getBeginLoc(), diag::warn_cmse_nonsecure_union) << 1;"}},
[l]={
["clang/test/Sema/arm-cmse.c"]={"clang/test/Sema/arm-cmse.c:35:10: warning: passing union across security boundary via return value may leak information [-Wcmse-union-leak]","clang/test/Sema/arm-cmse.c:51:7: warning: passing union across security boundary via parameter 1 may leak information [-Wcmse-union-leak]","clang/test/Sema/arm-cmse.c:54:8: warning: passing union across security boundary via parameter 0 may leak information [-Wcmse-union-leak]","clang/test/Sema/arm-cmse.c:56:8: warning: passing union across security boundary via parameter 2 may leak information [-Wcmse-union-leak]"}
}
},
["warn_cocoa_naming_owned_rule"]={
[j]={"objc-property-matches-cocoa-ownership-rule"},
[k]="objc-property-matches-cocoa-ownership-rule",
[g]="warn_cocoa_naming_owned_rule",
[b]="property follows Cocoa naming convention for returning \'owned\' objects",
[c]="property follows Cocoa naming convention for returning \'owned\' objects",
[d]=m,
[e]="property follows Cocoa naming convention for returning \'owned\' objects",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-property\\-matches\\-cocoa\\-ownership\\-rule[^\\]]*\\]",
[h]=n,
[a]={"65b13779118c",1389315228,"ObjectiveC. 1) Warn when @dynamic (as well as synthesize) ","ObjectiveC. 1) Warn when @dynamic (as well as synthesize) \nproperty has the naming convention that implies \'ownership\'.\n2) improve on diagnostic and make it property specific.\n3) fix the line number in the case of default property\nsynthesis. // rdar://15757510\n\nllvm-svn: 198905"},
[i]={{pb,2277,"void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {\n // ...\n for (const auto *PID : D->property_impls()) {\n // ...\n if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() && !PD->isClassProperty()) {\n // ...\n if (family == OMF_alloc || family == OMF_copy || family == OMF_mutableCopy || family == OMF_new) {\n if (getLangOpts().ObjCAutoRefCount)\n // ...\n else\n Diag(PD->getLocation(), diag::warn_cocoa_naming_owned_rule);"}}
},
["warn_collection_expr_type"]={
[g]="warn_collection_expr_type",
[b]="collection expression type %0 may not respond to %1",
[c]="collection expression type A may not respond to B",
[d]=m,
[e]="collection expression type (.*?) may not respond to (.*?)",
[f]=jb,
[h]=n,
[a]={"68e69ca9f9e0",1281651942,"Patch to issue warning when colllection expresion\'s type","Patch to issue warning when colllection expresion\'s type\ndoes not implement \'countByEnumeratingWithState\' API.\nImplements radar 7634669.\n\nllvm-svn: 110964"},
[i]={{X,2271,"ExprResult Sema::CheckObjCForCollectionOperand(SourceLocation forLoc, Expr *collection) {\n // ...\n // If we have a forward-declared type, we can\'t do this check.\n // Under ARC, it is an error not to have a forward-declared class.\n if (iface && (getLangOpts().ObjCAutoRefCount ? RequireCompleteType(forLoc, QualType(objectType, 0), diag::err_arc_collection_forward, collection) : !isCompleteType(forLoc, QualType(objectType, 0)))) {\n // ...\n } else if (iface || !objectType->qual_empty()) {\n // ...\n // If we didn\'t find it anywhere, give up.\n if (!method) {\n Diag(forLoc, diag::warn_collection_expr_type) << collection->getType() << selector << collection->getSourceRange();"}},
[l]={
["clang/test/AST/foreachtemplatized.mm"]={"clang/test/AST/foreachtemplatized.mm:10:3: warning: collection expression type \'I *\' may not respond to \'countByEnumeratingWithState:objects:count:\'","clang/test/AST/foreachtemplatized.mm:10:3: warning: collection expression type \'I *\' may not respond to \'countByEnumeratingWithState:objects:count:\'"}
}
},
["warn_comma_operator"]={
[j]={"comma"},
[k]="comma",
[g]="warn_comma_operator",
[b]="possible misuse of comma operator here",
[c]="possible misuse of comma operator here",
[d]=m,
[e]="possible misuse of comma operator here",
[f]=" \\[(?:\\-Werror,)?\\-Wcomma[^\\]]*\\]",
[h]=n,
[a]={"faca2d83b13e",1455839920,"Add -Wcomma warning to Clang.","Add -Wcomma warning to Clang.\n\n-Wcomma will detect and warn on most uses of the builtin comma operator. It\ncurrently whitelists the first and third statements of the for-loop. For other\ncases, the warning can be silenced by casting the first operand of the comma\noperator to void.\n\nDifferential Revision: http://reviews.llvm.org/D3976\n\nllvm-svn: 261278"},
[i]={{G,14632,"// Look for instances where it is likely the comma operator is confused with\n// another operator. There is an explicit list of acceptable expressions for\n// the left hand side of the comma operator, otherwise emit a warning.\nvoid Sema::DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc) {\n // ...\n Diag(Loc, diag::warn_comma_operator);"},{G,14698,"// C99 6.5.17\nstatic QualType CheckCommaOperands(Sema &S, ExprResult &LHS, ExprResult &RHS, SourceLocation Loc) {\n // ...\n if (!S.getDiagnostics().isIgnored(diag::warn_comma_operator, Loc))"},{X,898,"StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *thenStmt, SourceLocation ElseLoc, Stmt *elseStmt) {\n // ...\n if (CondExpr && (getLangOpts().C99 || getLangOpts().CPlusPlus) && !Diags.isIgnored(diag::warn_comma_operator, CondExpr->getExprLoc()))"},{X,1697,"StmtResult Sema::ActOnWhileStmt(SourceLocation WhileLoc, SourceLocation LParenLoc, ConditionResult Cond, SourceLocation RParenLoc, Stmt *Body) {\n // ...\n if (CondVal.second && !Diags.isIgnored(diag::warn_comma_operator, CondVal.second->getExprLoc()))"},{X,1726,"StmtResult Sema::ActOnDoStmt(SourceLocation DoLoc, Stmt *Body, SourceLocation WhileLoc, SourceLocation CondLParen, Expr *Cond, SourceLocation CondRParen) {\n // ...\n if (Cond && !getLangOpts().C99 && !getLangOpts().CPlusPlus && !Diags.isIgnored(diag::warn_comma_operator, Cond->getExprLoc()))"},{X,2177,"StmtResult Sema::ActOnForStmt(SourceLocation ForLoc, SourceLocation LParenLoc, Stmt *First, ConditionResult Second, FullExprArg third, SourceLocation RParenLoc, Stmt *Body) {\n // ...\n if (Second.get().second && !Diags.isIgnored(diag::warn_comma_operator, Second.get().second->getExprLoc()))"}},
[l]={
["clang/test/SemaCXX/warn-comma-operator.cpp"]={"clang/test/SemaCXX/warn-comma-operator.cpp:46:20: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:57:23: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:69:28: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:75:30: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:84:6: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:93:21: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:99:25: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:105:23: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:111:23: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:117:20: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:123:30: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:132:16: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:132:31: warning: possible misuse of comma operator here [-Wcomma]","clang/test/SemaCXX/warn-comma-operator.cpp:132:46: warning: possible misuse of comma operator here [-Wcomma]"}
}
},
["warn_comparison_always"]={
[j]={P,T,cb,Xb},
[k]=Xb,
[g]="warn_comparison_always",
[b]={{nil,s,"%select{self-|array }0comparison always evaluates to %select{a constant|true|false|\'std::strong_ordering::equal\'}1"},{B,F,"%select{self-|array }0comparison always evaluates to %select{a constant|%2}1"},{N,nil,"%select{self-|array }0comparison always evaluates to %select{false|true|a constant}1"}},
[c]={{nil,s,{{"self-","array "},"comparison always evaluates to ",{"a constant","true","false","\'std::strong_ordering::equal\'"}}},{B,F,{{"self-","array "},"comparison always evaluates to ",{"a constant","C"}}},{N,nil,{{"self-","array "},"comparison always evaluates to ",{"false","true","a constant"}}}},
[d]=m,
[e]="(?:self\\-|array )comparison always evaluates to (?:a constant|true|false|\'std\\:\\:strong_ordering\\:\\:equal\')",
[f]=" \\[(?:\\-Werror,)?\\-Wtautological\\-compare[^\\]]*\\]",
[h]=n,
[a]={"ec170db73d50",1276026634,"Warn about comparisons between arrays and improve self-comparison","Warn about comparisons between arrays and improve self-comparison\nwarnings, from Troy Straszheim! Fixes PR6163.\n\nllvm-svn: 105631"},
[i]={{G,12673,"/// Diagnose some forms of syntactically-obvious tautological comparison.\nstatic void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opc) {\n // ...\n if (!LHS->getBeginLoc().isMacroID() && !RHS->getBeginLoc().isMacroID()) {\n if (Expr::isSameComparisonOperand(LHS, RHS)) {\n // ...\n S.DiagRuntimeBehavior(Loc, nullptr,\n S.PDiag(diag::warn_comparison_always) << 0 /*self-comparison*/"},{G,12703,"/// Diagnose some forms of syntactically-obvious tautological comparison.\nstatic void diagnoseTautologicalComparison(Sema &S, SourceLocation Loc, Expr *LHS, Expr *RHS, BinaryOperatorKind Opc) {\n // ...\n if (!LHS->getBeginLoc().isMacroID() && !RHS->getBeginLoc().isMacroID()) {\n if (Expr::isSameComparisonOperand(LHS, RHS)) {\n // ...\n } else if (checkForArray(LHSStripped) && checkForArray(RHSStripped)) {\n // ...\n S.DiagRuntimeBehavior(Loc, nullptr,\n S.PDiag(diag::warn_comparison_always) << 1 /*array comparison*/"}},
[l]={
["clang/test/SemaObjC/self-comparison.m"]={"clang/test/SemaObjC/self-comparison.m:10:14: warning: self-comparison always evaluates to true [-Wtautological-compare]"}
}
},
["warn_comparison_bitwise_always"]={
[j]={P,T,cb,"tautological-bitwise-compare",Xb},
[k]="tautological-bitwise-compare",
[g]="warn_comparison_bitwise_always",
[b]="bitwise comparison always evaluates to %select{false|true}0",
[c]={{nil,nil,{"bitwise comparison always evaluates to ",{"false","true"}}}},
[d]=m,
[e]="bitwise comparison always evaluates to (?:false|true)",
[f]=" \\[(?:\\-Werror,)?\\-Wtautological\\-bitwise\\-compare[^\\]]*\\]",
[h]=n,
[a]={"7afd71e4ff5d",1400607071,"Add a check for tautological bitwise comparisons to -Wtautological-compare.","Add a check for tautological bitwise comparisons to -Wtautological-compare.\n\nThis catches issues like:\n\nif ((x & 8) == 4) { ... }\nif ((x | 4) != 3) { ... }\n\nPatch by Anders Rönnholm!\n\nllvm-svn: 209221"},
[i]={{M,177,"/// Warn on logical operator errors in CFGBuilder\nclass LogicalErrorHandler : public CFGCallback {\n // ...\n void compareBitwiseEquality(const BinaryOperator *B, bool isAlwaysTrue) override {\n // ...\n S.Diag(B->getExprLoc(), diag::warn_comparison_bitwise_always) << DiagRange << isAlwaysTrue;"}},
[l]={
["clang/test/Sema/warn-bitwise-compare.c"]={"clang/test/Sema/warn-bitwise-compare.c:95:9: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:53:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:52:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:50:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:49:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:47:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:46:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:45:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:43:17: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:42:16: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:41:17: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:40:20: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:38:19: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:37:18: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:35:20: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:34:18: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:32:20: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:31:18: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:29:16: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:28:16: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:27:16: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:25:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:24:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:23:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:21:16: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:20:16: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:19:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:18:15: warning: bitwise comparison always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:16:16: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:15:16: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:14:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:13:15: warning: bitwise comparison always evaluates to false [-Wtautological-bitwise-compare]"}
}
},
["warn_comparison_bitwise_or"]={
[j]={P,T,cb,"tautological-bitwise-compare",Xb},
[k]="tautological-bitwise-compare",
[g]={{nil,s,"warn_comparison_bitwise_or"}},
[b]={{nil,s,"bitwise or with non-zero value always evaluates to true"}},
[c]={{nil,s,"bitwise or with non-zero value always evaluates to true"}},
[d]=m,
[e]="bitwise or with non\\-zero value always evaluates to true",
[f]=" \\[(?:\\-Werror,)?\\-Wtautological\\-bitwise\\-compare[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={"7c11da0cfd33",1567434909,"[clang] New __attribute__((__clang_arm_mve_alias)).","[clang] New __attribute__((__clang_arm_mve_alias)).\n\nThis allows you to declare a function with a name of your choice (say\n`foo`), but have clang treat it as if it were a builtin function (say\n`__builtin_foo`), by writing\n\n static __inline__ __attribute__((__clang_arm_mve_alias(__builtin_foo)))\n int foo(args);\n\nI\'m intending to use this for the ACLE intrinsics for MVE, which have\nto be polymorphic on their argument types and also need to be\nimplemented by builtins. To avoid having to implement the polymorphism\nwith several layers of nested _Generic and make error reporting\nhideous, I want to make all the user-facing intrinsics correspond\ndirectly to clang builtins, so that after clang resolves\n__attribute__((overloadable)) polymorphism it\'s already holding the\nright BuiltinID for the intrinsic it selected.\n\nHowever, this commit itself just introduces the new attribute, and\ndoesn\'t use it for anything.\n\nTo avoid unanticipated side effects if this attribute is used to make\naliases to other builtins, there\'s a restriction mechanism: only\n(BuiltinID, alias) pairs that are approved by the function\nArmMveAliasValid() will be permitted. At present, that function\ndoesn\'t permit anything, because the Tablegen that will generate its\nlist of valid pairs isn\'t yet implemented. So the only test of this\nfacility is one that checks that an unapproved builtin _can\'t_ be\naliased.\n\nReviewers: dmgreen, miyuki, ostannard\n\nSubscribers: cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D67159"},
[i]={{M,186,"/// Warn on logical operator errors in CFGBuilder\nclass LogicalErrorHandler : public CFGCallback {\n // ...\n void compareBitwiseOr(const BinaryOperator *B) override {\n // ...\n S.Diag(B->getExprLoc(), diag::warn_comparison_bitwise_or) << DiagRange;"},{M,192,"/// Warn on logical operator errors in CFGBuilder\nclass LogicalErrorHandler : public CFGCallback {\n // ...\n static bool hasActiveDiagnostics(DiagnosticsEngine &Diags, SourceLocation Loc) { return !Diags.isIgnored(diag::warn_tautological_overlap_comparison, Loc) || !Diags.isIgnored(diag::warn_comparison_bitwise_or, Loc); }"}},
[l]={
["clang/test/Sema/warn-bitwise-compare.c"]={"clang/test/Sema/warn-bitwise-compare.c:104:9: warning: bitwise or with non-zero value always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:103:9: warning: bitwise or with non-zero value always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:101:12: warning: bitwise or with non-zero value always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:100:9: warning: bitwise or with non-zero value always evaluates to true [-Wtautological-bitwise-compare]","clang/test/Sema/warn-bitwise-compare.c:99:9: warning: bitwise or with non-zero value always evaluates to true [-Wtautological-bitwise-compare]"}
}
},
["warn_comparison_mixed_enum_types"]={
[j]={"enum-compare"},
[k]="enum-compare",
[g]={{nil,s,"warn_comparison_mixed_enum_types"}},
[b]={{nil,s,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2"}},
[c]={{nil,s,{{xb,wb,qb,ub,yb},Ob,{Nb,r}}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wenum\\-compare[^\\]]*\\]",
[h]={{nil,s,n}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1529,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n } else if (ACK == Sema::ACK_Conditional) {\n // ...\n } else if (ACK == Sema::ACK_Comparison) {\n // ...\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_comparison_mixed_enum_types_cxx20 : diag::warn_comparison_mixed_enum_types;"}},
[l]={
["clang/test/CodeGenObjC/objc-fixed-enum.m"]={"clang/test/CodeGenObjC/objc-fixed-enum.m:47:13: warning: comparison of different enumeration types (\'Enum0\' and \'Enum1\' (aka \'enum Enum1\')) [-Wenum-compare]","clang/test/CodeGenObjC/objc-fixed-enum.m:47:25: warning: comparison of different enumeration types (\'Enum1\' (aka \'enum Enum1\') and \'Enum2\') [-Wenum-compare]"}
}
},
["warn_comparison_mixed_enum_types_cxx20"]={
[j]={eb,"deprecated-enum-compare","enum-compare"},
[k]="deprecated-enum-compare",
[g]={{nil,t,"warn_comparison_mixed_enum_types_cxx20"}},
[b]={{nil,t,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2 is deprecated"}},
[c]={{nil,t,{{xb,wb,qb,ub,yb},Ob,{Nb,r}," is deprecated"}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|) is deprecated",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-enum\\-compare[^\\]]*\\]",
[h]={{nil,t,Gb}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1528,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n } else if (ACK == Sema::ACK_Conditional) {\n // ...\n } else if (ACK == Sema::ACK_Comparison) {\n // ...\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_comparison_mixed_enum_types_cxx20 : diag::warn_comparison_mixed_enum_types;"}},
[l]={
[yc]={"clang/test/CXX/expr/expr.arith.conv/p2.cpp:29:11: warning: comparison of different enumeration types (\'enum E1\' and \'enum E2\') is deprecated [-Wdeprecated-enum-compare]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:34:11: warning: comparison of different enumeration types (\'enum E1\' and \'enum E2\') is deprecated [-Wdeprecated-enum-compare]","clang/test/CXX/expr/expr.arith.conv/p2.cpp:39:10: warning: conditional expression between different enumeration types (\'enum E1\' and \'enum E2\') is deprecated [-Wdeprecated-enum-compare-conditional]"}
}
},
["warn_comparison_of_mixed_enum_types_switch"]={
[j]={"enum-compare","enum-compare-switch"},
[k]="enum-compare-switch",
[g]={{nil,N,"warn_comparison_of_mixed_enum_types_switch"}},
[b]={{nil,s,"comparison of different enumeration types in switch statement%diff{ ($ and $)|}0,1"},{B,N,"comparison of two values with different enumeration types in switch statement%diff{ ($ and $)|}0,1"}},
[c]={{nil,s,{"comparison of different enumeration types in switch statement",{" (A and B)",r}}},{B,N,{"comparison of two values with different enumeration types in switch statement",{" (A and B)",r}}}},
[d]=m,
[e]="comparison of different enumeration types in switch statement(?: \\((.*?) and (.*?)\\)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wenum\\-compare\\-switch[^\\]]*\\]",
[h]={{nil,N,n}},
[a]={"0284a20fbafa",1502312203,"[Sema] Assign new flag -Wenum-compare-switch to switch-related parts of -Wenum-compare","[Sema] Assign new flag -Wenum-compare-switch to switch-related parts of -Wenum-compare\n\nPatch by: Reka Nikolett Kovacs\n\nDifferential Revision: https://reviews.llvm.org/D36526\n\nllvm-svn: 310521"},
[i]={{X,1211,"static void checkEnumTypesInSwitchStmt(Sema &S, const Expr *Cond, const Expr *Case) {\n // ...\n S.Diag(Case->getExprLoc(), diag::warn_comparison_of_mixed_enum_types_switch) << CondType << CaseType << Cond->getSourceRange() << Case->getSourceRange();"}},
[l]={
["clang/test/Sema/switch.c"]={"clang/test/Sema/switch.c:385:8: warning: comparison of different enumeration types in switch statement (\'enum ExtendedEnum1\' and \'enum ExtendedEnum1_unrelated\') [-Wenum-compare-switch]"}
}
},
["warn_completion_handler_called_twice"]={
[j]={Ab,bc},
[k]=bc,
[g]={{nil,p,"warn_completion_handler_called_twice"}},
[b]={{nil,p,"completion handler is called twice"}},
[c]={{nil,p,"completion handler is called twice"}},
[d]=m,
[e]="completion handler is called twice",
[f]=" \\[(?:\\-Werror,)?\\-Wcompletion\\-handler[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{M,1689,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleDoubleCall(const ParmVarDecl *Parameter, const Expr *Call, const Expr *PrevCall, bool IsCompletionHandler, bool Poised) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_called_twice : diag::warn_called_once_gets_called_twice;"},{M,1757,"constexpr unsigned CompletionHandlerWarnings[]{diag::warn_completion_handler_never_called, diag::warn_completion_handler_never_called_when, diag::warn_completion_handler_called_twice};"}},
[l]={
[hc]={"clang/test/SemaObjC/warn-called-once.m:806:3: warning: completion handler is called twice [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:813:3: warning: completion handler is called twice [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:820:3: warning: completion handler is called twice [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:827:3: warning: completion handler is called twice [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:834:3: warning: completion handler is called twice [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1123:5: warning: completion handler is called twice [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1236:3: warning: completion handler is called twice [-Wcompletion-handler]"}
}
},
["warn_completion_handler_never_called"]={
[j]={Ab,bc},
[k]=bc,
[g]={{nil,p,"warn_completion_handler_never_called"}},
[b]={{nil,p,"%select{|captured }1completion handler is never called"}},
[c]={{nil,p,{{r,"captured "},"completion handler is never called"}}},
[d]=m,
[e]="(?:|captured )completion handler is never called",
[f]=" \\[(?:\\-Werror,)?\\-Wcompletion\\-handler[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{M,1699,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleNeverCalled(const ParmVarDecl *Parameter, bool IsCompletionHandler) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_never_called : diag::warn_called_once_never_called;"},{M,1729,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleCapturedNeverCalled(const ParmVarDecl *Parameter, const Decl *Where, bool IsCompletionHandler) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_never_called : diag::warn_called_once_never_called;"},{M,1755,"constexpr unsigned CompletionHandlerWarnings[]{diag::warn_completion_handler_never_called, diag::warn_completion_handler_never_called_when, diag::warn_completion_handler_called_twice};"}},
[l]={
[hc]={"clang/test/SemaObjC/warn-called-once.m:672:26: warning: completion handler is never called [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:676:26: warning: completion handler is never called [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:680:39: warning: completion handler is never called [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:899:28: warning: completion handler is never called [-Wcompletion-handler]"}
}
},
["warn_completion_handler_never_called_when"]={
[j]={Ab,bc},
[k]=bc,
[g]={{nil,p,"warn_completion_handler_never_called_when"}},
[b]={{nil,p,"completion handler is never %select{used|called}1 when %select{taking true branch|taking false branch|handling this case|none of the cases applies|entering the loop|skipping the loop|taking one of the branches}2"}},
[c]={{nil,p,{"completion handler is never ",{"used","called"}," when ",{"taking true branch","taking false branch","handling this case","none of the cases applies","entering the loop","skipping the loop","taking one of the branches"}}}},
[d]=m,
[e]="completion handler is never (?:used|called) when (?:taking true branch|taking false branch|handling this case|none of the cases applies|entering the loop|skipping the loop|taking one of the branches)",
[f]=" \\[(?:\\-Werror,)?\\-Wcompletion\\-handler[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={hb,1590001902,ib,kb},
[i]={{M,1710,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n // ...\n void handleNeverCalled(const ParmVarDecl *Parameter, const Decl *Function, const Stmt *Where, NeverCalledReason Reason, bool IsCalledDirectly, bool IsCompletionHandler) override {\n auto DiagToReport = IsCompletionHandler ? diag::warn_completion_handler_never_called_when : diag::warn_called_once_never_called_when;"},{M,1756,"constexpr unsigned CompletionHandlerWarnings[]{diag::warn_completion_handler_never_called, diag::warn_completion_handler_never_called_when, diag::warn_completion_handler_called_twice};"}},
[l]={
[hc]={"clang/test/SemaObjC/warn-called-once.m:726:3: warning: completion handler is never called when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:882:15: warning: completion handler is never used when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:892:15: warning: completion handler is never used when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:910:3: warning: completion handler is never called when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:939:3: warning: completion handler is never used when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:949:3: warning: completion handler is never called when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:958:3: warning: completion handler is never used when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:967:3: warning: completion handler is never called when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:983:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:976:3: warning: completion handler is never called when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1044:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1053:3: warning: completion handler is never called when taking true branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1062:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1069:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1076:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1083:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]","clang/test/SemaObjC/warn-called-once.m:1108:3: warning: completion handler is never called when taking false branch [-Wcompletion-handler]"}
}
},
["warn_compound_token_split_by_macro"]={
[j]={"compound-token-split","compound-token-split-by-macro"},
[k]="compound-token-split-by-macro",
[g]={{nil,p,"warn_compound_token_split_by_macro"}},
[b]={{nil,p,"%select{%1 and |}0%2 tokens %select{introducing statement expression|terminating statement expression|introducing attribute|terminating attribute|forming pointer to member type}3 appear in different macro expansion contexts"}},
[c]={{nil,p,{{"B and ",r},"C tokens ",{"introducing statement expression","terminating statement expression","introducing attribute","terminating attribute","forming pointer to member type"}," appear in different macro expansion contexts"}}},
[d]=m,
[e]="(?:(.*?) and |)(.*?) tokens (?:introducing statement expression|terminating statement expression|introducing attribute|terminating attribute|forming pointer to member type) appear in different macro expansion contexts",
[f]=" \\[(?:\\-Werror,)?\\-Wcompound\\-token\\-split\\-by\\-macro[^\\]]*\\]",
[h]={{nil,p,db}},
[a]={"5c63ae156e96",1597298751,"[OpenMP] Support nested OpenMP context selectors (declare variant)","[OpenMP] Support nested OpenMP context selectors (declare variant)\n\nDue to `omp begin/end declare variant`, OpenMP context selectors can be\nnested. This patch adds initial support for this so we can use it for\ntarget math variants. We should improve the detection of \"equivalent\"\nscores and user conditions, we should also revisit the data structures\nof the OMPTraitInfo object, however, both are not pressing issues right\nnow.\n\nReviewed By: JonChesterfield\n\nDifferential Revision: https://reviews.llvm.org/D85877"},
[i]={{"clang/lib/Parse/Parser.cpp",243,"void Parser::checkCompoundToken(SourceLocation FirstTokLoc, tok::TokenKind FirstTokKind, CompoundToken Op) {\n // ...\n // If either token is in a macro, we expect both tokens to come from the same\n // macro expansion.\n if ((FirstTokLoc.isMacroID() || SecondTokLoc.isMacroID()) && PP.getSourceManager().getFileID(FirstTokLoc) != PP.getSourceManager().getFileID(SecondTokLoc)) {\n Diag(FirstTokLoc, diag::warn_compound_token_split_by_macro) << (FirstTokKind == Tok.getKind()) << FirstTokKind << Tok.getKind() << static_cast<int>(Op) << SourceRange(FirstTokLoc);"}},
[l]={
["clang/test/Parser/compound-token-split.cpp"]={"clang/test/Parser/compound-token-split.cpp:15:3: warning: \'(\' and \'{\' tokens introducing statement expression appear in different macro expansion contexts [-Wcompound-token-split-by-macro]","clang/test/Parser/compound-token-split.cpp:15:16: warning: \'}\' and \')\' tokens terminating statement expression appear in different macro expansion contexts [-Wcompound-token-split-by-macro]","clang/test/Parser/compound-token-split.cpp:29:17: warning: \'}\' and \')\' tokens terminating statement expression appear in different macro expansion contexts [-Wcompound-token-split-by-macro]"}
}
},
["warn_compound_token_split_by_whitespace"]={
[j]={"compound-token-split","compound-token-split-by-space"},
[k]="compound-token-split-by-space",
[g]={{nil,p,"warn_compound_token_split_by_whitespace"}},
[b]={{nil,p,"%select{%1 and |}0%2 tokens %select{introducing statement expression|terminating statement expression|introducing attribute|terminating attribute|forming pointer to member type}3 are separated by whitespace"}},
[c]={{nil,p,{{"B and ",r},"C tokens ",{"introducing statement expression","terminating statement expression","introducing attribute","terminating attribute","forming pointer to member type"}," are separated by whitespace"}}},
[d]=m,
[e]="(?:(.*?) and |)(.*?) tokens (?:introducing statement expression|terminating statement expression|introducing attribute|terminating attribute|forming pointer to member type) are separated by whitespace",
[f]=" \\[(?:\\-Werror,)?\\-Wcompound\\-token\\-split\\-by\\-space[^\\]]*\\]",
[h]={{nil,p,db}},
[a]={"5c63ae156e96",1597298751,"[OpenMP] Support nested OpenMP context selectors (declare variant)","[OpenMP] Support nested OpenMP context selectors (declare variant)\n\nDue to `omp begin/end declare variant`, OpenMP context selectors can be\nnested. This patch adds initial support for this so we can use it for\ntarget math variants. We should improve the detection of \"equivalent\"\nscores and user conditions, we should also revisit the data structures\nof the OMPTraitInfo object, however, both are not pressing issues right\nnow.\n\nReviewed By: JonChesterfield\n\nDifferential Revision: https://reviews.llvm.org/D85877"},
[i]={{"clang/lib/Parse/Parser.cpp",257,"void Parser::checkCompoundToken(SourceLocation FirstTokLoc, tok::TokenKind FirstTokKind, CompoundToken Op) {\n // ...\n // We expect the tokens to abut.\n if (Tok.hasLeadingSpace() || Tok.isAtStartOfLine()) {\n // ...\n Diag(SpaceLoc, diag::warn_compound_token_split_by_whitespace) << (FirstTokKind == Tok.getKind()) << FirstTokKind << Tok.getKind() << static_cast<int>(Op) << SourceRange(FirstTokLoc, SecondTokLoc);"}}
},
["warn_concatenated_literal_array_init"]={
[j]={r,P,Nc,"string-concatenation"},
[k]="string-concatenation",
[g]={{nil,p,"warn_concatenated_literal_array_init"}},
[b]={{nil,p,"suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma?"}},
[c]={{nil,p,"suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma?"}},
[d]=m,
[e]="suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma\\?",
[f]=" \\[(?:\\-Werror,)?\\-Wstring\\-concatenation[^\\]]*\\]",
[h]={{nil,p,n}},
[a]={ab,1582847864,Z,Y},
[i]={{H,14154,"void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {\n // ...\n if (!var->getType()->isStructureType() && var->hasInit() && isa<InitListExpr>(var->getInit())) {\n // ...\n if (NumInits > 2)\n for (unsigned I = 0; I < NumInits; ++I) {\n // ...\n // Diagnose missing comma in string array initialization.\n // Do not warn when all the elements in the initializer are concatenated\n // together. Do not warn for macros too.\n if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {\n // ...\n if (OnlyOneMissingComma) {\n // ...\n Diag(SL->getStrTokenLoc(1), diag::warn_concatenated_literal_array_init) << Hints;"}},
[l]={
["clang/test/Sema/string-concat.c"]={"clang/test/Sema/string-concat.c:11:5: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:22:5: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:30:5: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:36:33: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:40:24: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:43:81: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:50:5: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:53:50: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]","clang/test/Sema/string-concat.c:66:36: warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]"}
}
},
["warn_concatenated_nsarray_literal"]={
[j]={"objc-string-concatenation"},
[k]="objc-string-concatenation",
[g]="warn_concatenated_nsarray_literal",
[b]="concatenated NSString literal for an NSArray expression - possibly missing a comma",
[c]="concatenated NSString literal for an NSArray expression - possibly missing a comma",
[d]=m,
[e]="concatenated NSString literal for an NSArray expression \\- possibly missing a comma",
[f]=" \\[(?:\\-Werror,)?\\-Wobjc\\-string\\-concatenation[^\\]]*\\]",
[h]=n,
[a]={"a802c3526bc8",1376437495,"ObjectiveC [QoI] issue warning if an element of an nsarray","ObjectiveC [QoI] issue warning if an element of an nsarray\nexpresison is a concatenated nsstring element.\n// rdar://14303083\n\nllvm-svn: 188332"},
[i]={{ec,488,"/// Check that the given expression is a valid element of an Objective-C\n/// collection literal.\nstatic ExprResult CheckObjCCollectionLiteralElement(Sema &S, Expr *Element, QualType T, bool ArrayLiteral = false) {\n // ...\n if (ArrayLiteral)\n if (ObjCStringLiteral *getString = dyn_cast<ObjCStringLiteral>(OrigElement)) {\n if (StringLiteral *SL = getString->getString()) {\n // ...\n if (numConcat > 1) {\n // ...\n if (!hasMacro)\n S.Diag(Element->getBeginLoc(), diag::warn_concatenated_nsarray_literal) << Element->getType();"}},
[l]={
["clang/test/SemaObjC/objc-array-literal.m"]={"clang/test/SemaObjC/objc-array-literal.m:60:19: warning: concatenated NSString literal for an NSArray expression - possibly missing a comma [-Wobjc-string-concatenation]","clang/test/SemaObjC/objc-array-literal.m:67:20: warning: concatenated NSString literal for an NSArray expression - possibly missing a comma [-Wobjc-string-concatenation]"}
}
},
["warn_condition_is_assignment"]={
[j]={P,T,"parentheses"},
[k]="parentheses",
[g]="warn_condition_is_assignment",
[b]=cc,
[c]=cc,
[d]=m,
[e]=cc,
[f]=" \\[(?:\\-Werror,)?\\-Wparentheses[^\\]]*\\]",
[h]=n,
[a]={"d5707abdfdd5",1255384747,"Implement -Wparentheses: warn about using assignments in contexts that require","Implement -Wparentheses: warn about using assignments in contexts that require\nconditions. Add a fixit to insert the parentheses. Also fix a very minor\npossible memory leak in \'for\' conditions.\n\nFixes PR 4876 and rdar://problem/7289172\n\nllvm-svn: 83907"},
[i]={{G,20853,"// Diagnose the s/=/==/ and s/\\|=/!=/ typos. Note that adding parentheses\n// will prevent this condition from triggering, which is what we want.\nvoid Sema::DiagnoseAssignmentAsCondition(Expr *E) {\n // ...\n unsigned diagnostic = diag::warn_condition_is_assignment;"}},
[l]={
["clang/test/CodeCompletion/crash-skipped-bodies-template-inst.cpp"]={"clang/test/CodeCompletion/crash-skipped-bodies-template-inst.cpp:15:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]","clang/test/CodeCompletion/crash-skipped-bodies-template-inst.cpp:15:9: warning: using the result of an assignment as a condition without parentheses [-Wparentheses]"}
}
},
["warn_condition_is_idiomatic_assignment"]={
[j]={"idiomatic-parentheses"},
[k]="idiomatic-parentheses",
[g]="warn_condition_is_idiomatic_assignment",
[b]=cc,
[c]=cc,
[d]=m,
[e]=cc,
[f]=" \\[(?:\\-Werror,)?\\-Widiomatic\\-parentheses[^\\]]*\\]",
[h]=n,
[a]={"b0e419e34dc0",1257984365,"Add <foo> = [<bar> nextObject] to the -Widiomatic-parentheses category,","Add <foo> = [<bar> nextObject] to the -Widiomatic-parentheses category,\nand give that category an explicit test. Generalize the internal diagnostic\nname.\n\nllvm-svn: 86905"},
[i]={{G,20857,"// Diagnose the s/=/==/ and s/\\|=/!=/ typos. Note that adding parentheses\n// will prevent this condition from triggering, which is what we want.\nvoid Sema::DiagnoseAssignmentAsCondition(Expr *E) {\n // ...\n if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {\n // ...\n // Greylist some idioms by putting them into a warning subcategory.\n if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {\n // ...\n // self = [<foo> init...]\n if (isSelfExpr(Op->getLHS()) && ME->getMethodFamily() == OMF_init)\n diagnostic = diag::warn_condition_is_idiomatic_assignment;"},{G,20878,"// Diagnose the s/=/==/ and s/\\|=/!=/ typos. Note that adding parentheses\n// will prevent this condition from triggering, which is what we want.\nvoid Sema::DiagnoseAssignmentAsCondition(Expr *E) {\n // ...\n if (BinaryOperator *Op = dyn_cast<BinaryOperator>(E)) {\n // ...\n // Greylist some idioms by putting them into a warning subcategory.\n if (ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(Op->getRHS()->IgnoreParenCasts())) {\n // ...\n // self = [<foo> init...]\n if (isSelfExpr(Op->getLHS()) && ME->getMethodFamily() == OMF_init)\n // ...\n // <foo> = [<bar> nextObject]\n else if (Sel.isUnarySelector() && Sel.getNameForSlot(0) == \"nextObject\")\n diagnostic = diag::warn_condition_is_idiomatic_assignment;"}}
},
["warn_conditional_mixed_enum_types"]={
[j]={Bb,"enum-compare-conditional",jc,Cb},
[k]="enum-compare-conditional",
[g]={{nil,s,"warn_conditional_mixed_enum_types"}},
[b]={{nil,s,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2"}},
[c]={{nil,s,{{xb,wb,qb,ub,yb},Ob,{Nb,r}}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wenum\\-compare\\-conditional[^\\]]*\\]",
[h]={{nil,s,ac}},
[a]={"7c11da0cfd33",1567434909,"[clang] New __attribute__((__clang_arm_mve_alias)).","[clang] New __attribute__((__clang_arm_mve_alias)).\n\nThis allows you to declare a function with a name of your choice (say\n`foo`), but have clang treat it as if it were a builtin function (say\n`__builtin_foo`), by writing\n\n static __inline__ __attribute__((__clang_arm_mve_alias(__builtin_foo)))\n int foo(args);\n\nI\'m intending to use this for the ACLE intrinsics for MVE, which have\nto be polymorphic on their argument types and also need to be\nimplemented by builtins. To avoid having to implement the polymorphism\nwith several layers of nested _Generic and make error reporting\nhideous, I want to make all the user-facing intrinsics correspond\ndirectly to clang builtins, so that after clang resolves\n__attribute__((overloadable)) polymorphism it\'s already holding the\nright BuiltinID for the intrinsic it selected.\n\nHowever, this commit itself just introduces the new attribute, and\ndoesn\'t use it for anything.\n\nTo avoid unanticipated side effects if this attribute is used to make\naliases to other builtins, there\'s a restriction mechanism: only\n(BuiltinID, alias) pairs that are approved by the function\nArmMveAliasValid() will be permitted. At present, that function\ndoesn\'t permit anything, because the Tablegen that will generate its\nlist of valid pairs isn\'t yet implemented. So the only test of this\nfacility is one that checks that an unapproved builtin _can\'t_ be\naliased.\n\nReviewers: dmgreen, miyuki, ostannard\n\nSubscribers: cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D67159"},
[i]={{G,1523,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n } else if (ACK == Sema::ACK_Conditional) {\n // ...\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_conditional_mixed_enum_types_cxx20 : diag::warn_conditional_mixed_enum_types;"}}
},
["warn_conditional_mixed_enum_types_cxx20"]={
[j]={Bb,eb,"deprecated-enum-compare-conditional","enum-compare-conditional",jc,Cb},
[k]="deprecated-enum-compare-conditional",
[g]={{nil,t,"warn_conditional_mixed_enum_types_cxx20"}},
[b]={{nil,t,"%select{arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of}0 different enumeration types%diff{ ($ and $)|}1,2 is deprecated"}},
[c]={{nil,t,{{xb,wb,qb,ub,yb},Ob,{Nb,r}," is deprecated"}}},
[d]=m,
[e]="(?:arithmetic between|bitwise operation between|comparison of|conditional expression between|compound assignment of) different enumeration types(?: \\((.*?) and (.*?)\\)|) is deprecated",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-enum\\-compare\\-conditional[^\\]]*\\]",
[h]={{nil,t,Gb}},
[a]={zb,1575504770,Db,Eb},
[i]={{G,1522,"/// Check that the usual arithmetic conversions can be performed on this pair of\n/// expressions that might be of enumeration type.\nstatic void checkEnumArithmeticConversions(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc, Sema::ArithConvKind ACK) {\n // ...\n if ((!IsCompAssign && LEnum && R->isFloatingType()) || (REnum && L->isFloatingType())) {\n // ...\n } else if (!IsCompAssign && LEnum && REnum && !S.Context.hasSameUnqualifiedType(L, R)) {\n // ...\n if (!L->castAs<EnumType>()->getDecl()->hasNameForLinkage() || !R->castAs<EnumType>()->getDecl()->hasNameForLinkage()) {\n // ...\n } else if (ACK == Sema::ACK_Conditional) {\n // ...\n DiagID = S.getLangOpts().CPlusPlus20 ? diag::warn_conditional_mixed_enum_types_cxx20 : diag::warn_conditional_mixed_enum_types;"}}
},
["warn_conflicting_nullability_attr_overriding_param_types"]={
[j]={"nullability"},
[k]="nullability",
[g]="warn_conflicting_nullability_attr_overriding_param_types",
[b]="conflicting nullability specifier on parameter types, %0 conflicts with existing specifier %1",
[c]="conflicting nullability specifier on parameter types, A conflicts with existing specifier B",
[d]=m,
[e]="conflicting nullability specifier on parameter types, (.*?) conflicts with existing specifier (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wnullability[^\\]]*\\]",
[h]="Nullability Issue",
[a]={"813a066f16df",1434737678,"Extend type nullability qualifiers for Objective-C.","Extend type nullability qualifiers for Objective-C.\n\nIntroduce context-sensitive, non-underscored nullability specifiers\n(nonnull, nullable, null_unspecified) for Objective-C method return\ntypes, method parameter types, and properties.\n\nIntroduce Objective-C-specific semantics, including computation of the\nnullability of the result of a message send, merging of nullability\ninformation from the @interface of a class into its @implementation,\netc .\n\nThis is the Objective-C part of rdar://problem/18868820.\n\nllvm-svn: 240154"},
[i]={{W,2460,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n // ...\n if (Warn && IsOverridingMode && !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) && !S.Context.hasSameNullabilityTypeQualifier(ImplTy, IfaceTy, true)) {\n S.Diag(ImplVar->getLocation(), diag::warn_conflicting_nullability_attr_overriding_param_types) << DiagNullabilityKind(*ImplTy->getNullability(), ((ImplVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0)) << DiagNullabilityKind(*IfaceTy->getNullability(), ((IfaceVar->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0));"}},
[l]={
["clang/test/SemaObjC/override-nullability.m"]={"clang/test/SemaObjC/override-nullability.m:12:32: warning: conflicting nullability specifier on parameter types, \'nonnull\' conflicts with existing specifier \'nullable\' [-Wnullability]"}
}
},
["warn_conflicting_nullability_attr_overriding_ret_types"]={
[j]={"nullability"},
[k]="nullability",
[g]="warn_conflicting_nullability_attr_overriding_ret_types",
[b]="conflicting nullability specifier on return types, %0 conflicts with existing specifier %1",
[c]="conflicting nullability specifier on return types, A conflicts with existing specifier B",
[d]=m,
[e]="conflicting nullability specifier on return types, (.*?) conflicts with existing specifier (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wnullability[^\\]]*\\]",
[h]="Nullability Issue",
[a]={"813a066f16df",1434737678,"Extend type nullability qualifiers for Objective-C.","Extend type nullability qualifiers for Objective-C.\n\nIntroduce context-sensitive, non-underscored nullability specifiers\n(nonnull, nullable, null_unspecified) for Objective-C method return\ntypes, method parameter types, and properties.\n\nIntroduce Objective-C-specific semantics, including computation of the\nnullability of the result of a message send, merging of nullability\ninformation from the @interface of a class into its @implementation,\netc .\n\nThis is the Objective-C part of rdar://problem/18868820.\n\nllvm-svn: 240154"},
[i]={{W,2376,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n // ...\n if (Warn && IsOverridingMode && !isa<ObjCImplementationDecl>(MethodImpl->getDeclContext()) && !S.Context.hasSameNullabilityTypeQualifier(MethodImpl->getReturnType(), MethodDecl->getReturnType(), false)) {\n // ...\n S.Diag(MethodImpl->getLocation(), diag::warn_conflicting_nullability_attr_overriding_ret_types) << DiagNullabilityKind(nullabilityMethodImpl, ((MethodImpl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0)) << DiagNullabilityKind(nullabilityMethodDecl, ((MethodDecl->getObjCDeclQualifier() & Decl::OBJC_TQ_CSNullability) != 0));"}},
[l]={
["clang/test/SemaObjC/override-nullability.m"]={"clang/test/SemaObjC/override-nullability.m:12:1: warning: conflicting nullability specifier on return types, \'nullable\' conflicts with existing specifier \'nonnull\' [-Wnullability]"}
}
},
["warn_conflicting_overriding_param_modifiers"]={
[j]={tb},
[k]=tb,
[g]="warn_conflicting_overriding_param_modifiers",
[b]="conflicting distributed object modifiers on parameter type in declaration of %0",
[c]="conflicting distributed object modifiers on parameter type in declaration of A",
[d]=m,
[e]="conflicting distributed object modifiers on parameter type in declaration of (.*?)",
[f]=Oc,
[h]=n,
[a]={Lc,1312996590,Pc,Qc},
[i]={{W,2440,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n if (IsProtocolMethodDecl && objcModifiersConflict(ImplVar->getObjCDeclQualifier(), IfaceVar->getObjCDeclQualifier())) {\n if (Warn) {\n if (IsOverridingMode)\n S.Diag(ImplVar->getLocation(), diag::warn_conflicting_overriding_param_modifiers) << getTypeRange(ImplVar->getTypeSourceInfo()) << MethodImpl->getDeclName();"}}
},
["warn_conflicting_overriding_param_types"]={
[j]={tb},
[k]=tb,
[g]="warn_conflicting_overriding_param_types",
[b]="conflicting parameter types in declaration of %0%diff{: $ vs $|}1,2",
[c]={{nil,nil,{"conflicting parameter types in declaration of A",{": B vs C",r}}}},
[d]=m,
[e]="conflicting parameter types in declaration of (.*?)(?:\\: (.*?) vs (.*?)|)",
[f]=Oc,
[h]=n,
[a]={Lc,1312996590,Pc,Qc},
[i]={{W,2475,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n // ...\n unsigned DiagID = IsOverridingMode ? diag::warn_conflicting_overriding_param_types : diag::warn_conflicting_param_types;"}},
[l]={
["clang/test/SemaObjC/qualified-protocol-method-conflicts.m"]={"clang/test/SemaObjC/qualified-protocol-method-conflicts.m:18:21: warning: conflicting parameter types in declaration of \'setX:\': \'float\' vs \'int\' [-Woverriding-method-mismatch]","clang/test/SemaObjC/qualified-protocol-method-conflicts.m:26:23: warning: conflicting parameter types in declaration of \'setX:\': \'int\' vs \'float\' [-Woverriding-method-mismatch]","clang/test/SemaObjC/qualified-protocol-method-conflicts.m:37:21: warning: conflicting parameter types in declaration of \'setX:\': \'float\' vs \'int\' [-Woverriding-method-mismatch]"}
}
},
["warn_conflicting_overriding_ret_type_modifiers"]={
[j]={tb},
[k]=tb,
[g]="warn_conflicting_overriding_ret_type_modifiers",
[b]="conflicting distributed object modifiers on return type in declaration of %0",
[c]="conflicting distributed object modifiers on return type in declaration of A",
[d]=m,
[e]="conflicting distributed object modifiers on return type in declaration of (.*?)",
[f]=Oc,
[h]=n,
[a]={Lc,1312996590,Pc,Qc},
[i]={{W,2358,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n if (IsProtocolMethodDecl && objcModifiersConflict(MethodDecl->getObjCDeclQualifier(), MethodImpl->getObjCDeclQualifier())) {\n if (Warn) {\n S.Diag(MethodImpl->getLocation(), (IsOverridingMode ? diag::warn_conflicting_overriding_ret_type_modifiers : diag::warn_conflicting_ret_type_modifiers)) << MethodImpl->getDeclName() << MethodImpl->getReturnTypeSourceRange();"}},
[l]={
["clang/test/SemaObjC/class-protocol-method-match.m"]={"clang/test/SemaObjC/class-protocol-method-match.m:26:1: warning: conflicting distributed object modifiers on return type in declaration of \'bud\' [-Woverriding-method-mismatch]"}
}
},
["warn_conflicting_overriding_ret_types"]={
[j]={tb},
[k]=tb,
[g]="warn_conflicting_overriding_ret_types",
[b]="conflicting return type in declaration of %0%diff{: $ vs $|}1,2",
[c]={{nil,nil,{"conflicting return type in declaration of A",{": B vs C",r}}}},
[d]=m,
[e]="conflicting return type in declaration of (.*?)(?:\\: (.*?) vs (.*?)|)",
[f]=Oc,
[h]=n,
[a]={Lc,1312996590,Pc,Qc},
[i]={{W,2393,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n // ...\n unsigned DiagID = IsOverridingMode ? diag::warn_conflicting_overriding_ret_types : diag::warn_conflicting_ret_types;"}},
[l]={
["clang/test/SemaObjC/qualified-protocol-method-conflicts.m"]={"clang/test/SemaObjC/qualified-protocol-method-conflicts.m:19:1: warning: conflicting return type in declaration of \'C\': \'float\' vs \'int\' [-Woverriding-method-mismatch]","clang/test/SemaObjC/qualified-protocol-method-conflicts.m:27:1: warning: conflicting return type in declaration of \'C\': \'int\' vs \'float\' [-Woverriding-method-mismatch]","clang/test/SemaObjC/qualified-protocol-method-conflicts.m:38:1: warning: conflicting return type in declaration of \'C\': \'float\' vs \'int\' [-Woverriding-method-mismatch]"}
}
},
["warn_conflicting_overriding_variadic"]={
[j]={tb},
[k]=tb,
[g]="warn_conflicting_overriding_variadic",
[b]=lc,
[c]=lc,
[d]=m,
[e]=lc,
[f]=Oc,
[h]=n,
[a]={Lc,1312996590,Pc,Qc},
[i]={{W,2623,"void Sema::CheckConflictingOverridingMethod(ObjCMethodDecl *Method, ObjCMethodDecl *Overridden, bool IsProtocolMethodDecl) {\n // ...\n if (Method->isVariadic() != Overridden->isVariadic()) {\n Diag(Method->getLocation(), diag::warn_conflicting_overriding_variadic);"}}
},
["warn_conflicting_param_modifiers"]={
[j]={"distributed-object-modifiers"},
[k]="distributed-object-modifiers",
[g]="warn_conflicting_param_modifiers",
[b]="conflicting distributed object modifiers on parameter type in implementation of %0",
[c]="conflicting distributed object modifiers on parameter type in implementation of A",
[d]=m,
[e]="conflicting distributed object modifiers on parameter type in implementation of (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wdistributed\\-object\\-modifiers[^\\]]*\\]",
[h]=n,
[a]={"d7b0cb538813",1298332155,"Warn when type modifiers on objc method declarations in","Warn when type modifiers on objc method declarations in\nprotocols do not match with method implementation.\n// rdar://7076235\n\nllvm-svn: 126162"},
[i]={{W,2444,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n if (IsProtocolMethodDecl && objcModifiersConflict(ImplVar->getObjCDeclQualifier(), IfaceVar->getObjCDeclQualifier())) {\n if (Warn) {\n if (IsOverridingMode)\n // ...\n else\n S.Diag(ImplVar->getLocation(), diag::warn_conflicting_param_modifiers) << getTypeRange(ImplVar->getTypeSourceInfo()) << MethodImpl->getDeclName();"}},
[l]={
["clang/test/SemaObjC/dist-object-modifiers.m"]={"clang/test/SemaObjC/dist-object-modifiers.m:17:21: warning: conflicting distributed object modifiers on parameter type in implementation of \'doStuff:\' [-Wdistributed-object-modifiers]","clang/test/SemaObjC/dist-object-modifiers.m:19:24: warning: conflicting distributed object modifiers on parameter type in implementation of \'stillMore::\' [-Wdistributed-object-modifiers]","clang/test/SemaObjC/dist-object-modifiers.m:19:42: warning: conflicting distributed object modifiers on parameter type in implementation of \'stillMore::\' [-Wdistributed-object-modifiers]"}
}
},
["warn_conflicting_param_types"]={
[j]={"mismatched-parameter-types"},
[k]="mismatched-parameter-types",
[g]="warn_conflicting_param_types",
[b]="conflicting parameter types in implementation of %0%diff{: $ vs $|}1,2",
[c]={{nil,nil,{"conflicting parameter types in implementation of A",{": B vs C",r}}}},
[d]=m,
[e]="conflicting parameter types in implementation of (.*?)(?:\\: (.*?) vs (.*?)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wmismatched\\-parameter\\-types[^\\]]*\\]",
[h]=n,
[a]={"67f35b051b60",1239479922,"improve the \'conflicting types\' diagnostics to include correct location info, now","improve the \'conflicting types\' diagnostics to include correct location info, now\nthat it is plumbed through Sema. On a file from growl, we used to emit:\n\nt.mi:107059:1: warning: conflicting types for \'removePluginHandler:forPluginTypes:\'\n- (void) removePluginHandler:(id <GrowlPluginHandler>)handler forPluginTypes:(NSSet *)extensions {\n^\nt.mi:105280:1: note: previous definition is here\n- (void) removePluginHandler:(id <NSObject>)handler forPluginTypes:(NSSet *)types;\n^\n\nnow we produce:\n\nt.mi:107059:55: warning: conflicting parameter types in implementation of \'removePluginHandler:forPluginTypes:\': \'id<NSObject>\' vs \'id<GrowlPluginHandler>\'\n- (void) removePluginHandler:(id <GrowlPluginHandler>)handler forPluginTypes:(NSSet *)extensions {\n ^\nt.mi:105280:45: note: previous definition is here\n- (void) removePluginHandler:(id <NSObject>)handler forPluginTypes:(NSSet *)types;\n ^\n\nWe still don\'t have proper loc info for properties, hence the FIXME.\n\nrdar://6782494\n\nllvm-svn: 68879"},
[i]={{W,2476,"static bool CheckMethodOverrideParam(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, ParmVarDecl *ImplVar, ParmVarDecl *IfaceVar, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n // ...\n unsigned DiagID = IsOverridingMode ? diag::warn_conflicting_overriding_param_types : diag::warn_conflicting_param_types;"}},
[l]={
["clang/test/SemaObjC/method-typecheck-1.m"]={"clang/test/SemaObjC/method-typecheck-1.m:10:25: warning: conflicting parameter types in implementation of \'setMoo:\': \'int\' vs \'float\' [-Wmismatched-parameter-types]","clang/test/SemaObjC/method-typecheck-1.m:23:12: warning: conflicting parameter types in implementation of \'cMoo:\': \'int\' vs \'float\' [-Wmismatched-parameter-types]","clang/test/SemaObjC/method-typecheck-1.m:34:9: warning: conflicting parameter types in implementation of \'setCat:\': \'int\' vs \'float\' [-Wmismatched-parameter-types]"}
}
},
["warn_conflicting_ret_type_modifiers"]={
[j]={"distributed-object-modifiers"},
[k]="distributed-object-modifiers",
[g]="warn_conflicting_ret_type_modifiers",
[b]="conflicting distributed object modifiers on return type in implementation of %0",
[c]="conflicting distributed object modifiers on return type in implementation of A",
[d]=m,
[e]="conflicting distributed object modifiers on return type in implementation of (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wdistributed\\-object\\-modifiers[^\\]]*\\]",
[h]=n,
[a]={"d7b0cb538813",1298332155,"Warn when type modifiers on objc method declarations in","Warn when type modifiers on objc method declarations in\nprotocols do not match with method implementation.\n// rdar://7076235\n\nllvm-svn: 126162"},
[i]={{W,2359,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n if (IsProtocolMethodDecl && objcModifiersConflict(MethodDecl->getObjCDeclQualifier(), MethodImpl->getObjCDeclQualifier())) {\n if (Warn) {\n S.Diag(MethodImpl->getLocation(), (IsOverridingMode ? diag::warn_conflicting_overriding_ret_type_modifiers : diag::warn_conflicting_ret_type_modifiers)) << MethodImpl->getDeclName() << MethodImpl->getReturnTypeSourceRange();"}},
[l]={
["clang/test/SemaObjC/dist-object-modifiers.m"]={"clang/test/SemaObjC/dist-object-modifiers.m:16:1: warning: conflicting distributed object modifiers on return type in implementation of \'serverPID\' [-Wdistributed-object-modifiers]","clang/test/SemaObjC/dist-object-modifiers.m:19:1: warning: conflicting distributed object modifiers on return type in implementation of \'stillMore::\' [-Wdistributed-object-modifiers]"}
}
},
["warn_conflicting_ret_types"]={
[j]={"mismatched-return-types"},
[k]="mismatched-return-types",
[g]="warn_conflicting_ret_types",
[b]="conflicting return type in implementation of %0%diff{: $ vs $|}1,2",
[c]={{nil,nil,{"conflicting return type in implementation of A",{": B vs C",r}}}},
[d]=m,
[e]="conflicting return type in implementation of (.*?)(?:\\: (.*?) vs (.*?)|)",
[f]=" \\[(?:\\-Werror,)?\\-Wmismatched\\-return\\-types[^\\]]*\\]",
[h]=n,
[a]={"67f35b051b60",1239479922,"improve the \'conflicting types\' diagnostics to include correct location info, now","improve the \'conflicting types\' diagnostics to include correct location info, now\nthat it is plumbed through Sema. On a file from growl, we used to emit:\n\nt.mi:107059:1: warning: conflicting types for \'removePluginHandler:forPluginTypes:\'\n- (void) removePluginHandler:(id <GrowlPluginHandler>)handler forPluginTypes:(NSSet *)extensions {\n^\nt.mi:105280:1: note: previous definition is here\n- (void) removePluginHandler:(id <NSObject>)handler forPluginTypes:(NSSet *)types;\n^\n\nnow we produce:\n\nt.mi:107059:55: warning: conflicting parameter types in implementation of \'removePluginHandler:forPluginTypes:\': \'id<NSObject>\' vs \'id<GrowlPluginHandler>\'\n- (void) removePluginHandler:(id <GrowlPluginHandler>)handler forPluginTypes:(NSSet *)extensions {\n ^\nt.mi:105280:45: note: previous definition is here\n- (void) removePluginHandler:(id <NSObject>)handler forPluginTypes:(NSSet *)types;\n ^\n\nWe still don\'t have proper loc info for properties, hence the FIXME.\n\nrdar://6782494\n\nllvm-svn: 68879"},
[i]={{W,2394,"static bool CheckMethodOverrideReturn(Sema &S, ObjCMethodDecl *MethodImpl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl, bool IsOverridingMode, bool Warn) {\n // ...\n unsigned DiagID = IsOverridingMode ? diag::warn_conflicting_overriding_ret_types : diag::warn_conflicting_ret_types;"}},
[l]={
["clang/test/Parser/objc-recover.mm"]={"clang/test/Parser/objc-recover.mm:23:1: warning: conflicting return type in implementation of \'foo\': \'void\' vs \'id\' [-Wmismatched-return-types]","clang/test/Parser/objc-recover.mm:25:1: warning: conflicting return type in implementation of \'bar\': \'void\' vs \'id\' [-Wmismatched-return-types]","clang/test/Parser/objc-recover.mm:44:1: warning: conflicting return type in implementation of \'test\': \'id\' vs \'void\' [-Wmismatched-return-types]","clang/test/Parser/objc-recover.mm:63:1: warning: conflicting return type in implementation of \'PWEN_foo\': \'void\' vs \'id\' [-Wmismatched-return-types]"}
}
},
["warn_conflicting_variadic"]={
[g]="warn_conflicting_variadic",
[b]=lc,
[c]=lc,
[d]=m,
[e]=lc,
[f]=jb,
[h]=n,
[a]={"5981b04718ca",1274484538,"Clang missing warning about conflicting declaration vs. definition ","Clang missing warning about conflicting declaration vs. definition \nfor variable arguments list methods. (radar 8006060).\n\nllvm-svn: 104407"},
[i]={{W,2600,"void Sema::WarnConflictingTypedMethods(ObjCMethodDecl *ImpMethodDecl, ObjCMethodDecl *MethodDecl, bool IsProtocolMethodDecl) {\n // ...\n if (ImpMethodDecl->isVariadic() != MethodDecl->isVariadic()) {\n Diag(ImpMethodDecl->getLocation(), diag::warn_conflicting_variadic);"}},
[l]={
["clang/test/SemaObjC/class-protocol-method-match.m"]={"clang/test/SemaObjC/class-protocol-method-match.m:32:1: warning: conflicting variadic declaration of method and its implementation [-Woverriding-method-mismatch]"}
}
},
["warn_consteval_if_always_true"]={
[j]={"redundant-consteval-if"},
[k]="redundant-consteval-if",
[g]={{nil,z,"warn_consteval_if_always_true"}},
[b]={{nil,z,"consteval if is always true in an %select{unevaluated|immediate}0 context"}},
[c]={{nil,z,{"consteval if is always true in an ",{"unevaluated","immediate"}," context"}}},
[d]=m,
[e]="consteval if is always true in an (?:unevaluated|immediate) context",
[f]=" \\[(?:\\-Werror,)?\\-Wredundant\\-consteval\\-if[^\\]]*\\]",
[h]={{nil,z,n}},
[a]={Wb,1615397021,Vb,Ub},
[i]={{X,946,"StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *thenStmt, SourceLocation ElseLoc, Stmt *elseStmt) {\n // ...\n if (ConstevalOrNegatedConsteval) {\n // ...\n if (isUnevaluatedContext() || Immediate)\n Diags.Report(IfLoc, diag::warn_consteval_if_always_true) << Immediate;"}},
[l]={
["clang/test/SemaCXX/cxx2b-consteval-if.cpp"]={"clang/test/SemaCXX/cxx2b-consteval-if.cpp:21:5: warning: consteval if is always true in an immediate context [-Wredundant-consteval-if]"}
}
},
["warn_constexpr_unscoped_enum_out_of_range"]={
[j]={"enum-constexpr-conversion"},
[k]="enum-constexpr-conversion",
[g]={{nil,v,"warn_constexpr_unscoped_enum_out_of_range"}},
[b]="integer value %0 is outside the valid range of values [%1, %2] for the enumeration type %3",
[c]="integer value A is outside the valid range of values [B, C] for the enumeration type D",
[d]=zc,
[e]="integer value (.*?) is outside the valid range of values \\[(.*?), (.*?)\\] for the enumeration type (.*?)",
[f]=" \\[[^\\]]*\\-Wenum\\-constexpr\\-conversion[^\\]]*\\]",
[h]={{nil,v,O}},
[a]={"ec273d3e3a8c",1643408541,"Add a warning for not packing non-POD members in packed structs","Add a warning for not packing non-POD members in packed structs\n\nDifferential Revision: https://reviews.llvm.org/D118511"},
[i]={{"clang/lib/AST/ExprConstant.cpp",13778,"/// HandleCast - This is used to evaluate implicit or explicit casts where the\n/// result type is integer.\nbool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {\n // ...\n case CK_IntegralCast: {\n // ...\n if (Info.Ctx.getLangOpts().CPlusPlus && Info.InConstantContext && Info.EvalMode == EvalInfo::EM_ConstantExpression && DestType->isEnumeralType()) {\n // ...\n // Check that the value is within the range of the enumeration values.\n //\n // This corressponds to [expr.static.cast]p10 which says:\n // A value of integral or enumeration type can be explicitly converted\n // to a complete enumeration type ... If the enumeration type does not\n // have a fixed underlying type, the value is unchanged if the original\n // value is within the range of the enumeration values ([dcl.enum]), and\n // otherwise, the behavior is undefined.\n //\n // This was resolved as part of DR2338 which has CD5 status.\n if (!ED->isFixed()) {\n // ...\n if (ED->getNumNegativeBits() && ConstexprVar && (Max.slt(Result.getInt().getSExtValue()) || Min.sgt(Result.getInt().getSExtValue())))\n Info.Ctx.getDiagnostics().Report(E->getExprLoc(), diag::warn_constexpr_unscoped_enum_out_of_range) << llvm::toString(Result.getInt(), 10) << Min.getSExtValue() << Max.getSExtValue() << ED;"},{"clang/lib/AST/ExprConstant.cpp",13784,"/// HandleCast - This is used to evaluate implicit or explicit casts where the\n/// result type is integer.\nbool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {\n // ...\n case CK_IntegralCast: {\n // ...\n if (Info.Ctx.getLangOpts().CPlusPlus && Info.InConstantContext && Info.EvalMode == EvalInfo::EM_ConstantExpression && DestType->isEnumeralType()) {\n // ...\n // Check that the value is within the range of the enumeration values.\n //\n // This corressponds to [expr.static.cast]p10 which says:\n // A value of integral or enumeration type can be explicitly converted\n // to a complete enumeration type ... If the enumeration type does not\n // have a fixed underlying type, the value is unchanged if the original\n // value is within the range of the enumeration values ([dcl.enum]), and\n // otherwise, the behavior is undefined.\n //\n // This was resolved as part of DR2338 which has CD5 status.\n if (!ED->isFixed()) {\n // ...\n if (ED->getNumNegativeBits() && ConstexprVar && (Max.slt(Result.getInt().getSExtValue()) || Min.sgt(Result.getInt().getSExtValue())))\n // ...\n else if (!ED->getNumNegativeBits() && ConstexprVar && Max.ult(Result.getInt().getZExtValue()))\n Info.Ctx.getDiagnostics().Report(E->getExprLoc(), diag::warn_constexpr_unscoped_enum_out_of_range) << llvm::toString(Result.getInt(), 10) << Min.getZExtValue() << Max.getZExtValue() << ED;"}},
[l]={
["clang/test/SemaCXX/cxx2a-consteval.cpp"]={"clang/test/SemaCXX/cxx2a-consteval.cpp:902:49: error: integer value -1 is outside the valid range of values [0, 1] for the enumeration type \'E\' [-Wenum-constexpr-conversion]"}
}
},
["warn_conv_to_base_not_used"]={
[j]={pc},
[k]=pc,
[g]="warn_conv_to_base_not_used",
[b]="conversion function converting %0 to its base class %1 will never be used",
[c]="conversion function converting A to its base class B will never be used",
[d]=m,
[e]="conversion function converting (.*?) to its base class (.*?) will never be used",
[f]=" \\[(?:\\-Werror,)?\\-Wclass\\-conversion[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{C,11177,"/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete\n/// the declaration of the given C++ conversion function. This routine\n/// is responsible for recording the conversion function in the C++\n/// class, if possible.\nDecl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {\n // ...\n if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared && Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)\n // ...\n else if (Conversion->size_overridden_methods() != 0)\n // ...\n else if (ConvType->isRecordType()) {\n // ...\n if (ConvType == ClassType)\n // ...\n else if (IsDerivedFrom(Conversion->getLocation(), ClassType, ConvType))\n Diag(Conversion->getLocation(), diag::warn_conv_to_base_not_used) << ClassType << ConvType;"}},
[l]={
["clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5.cpp"]={"clang/test/CXX/dcl.decl/dcl.init/dcl.init.ref/p5.cpp:30:5: warning: conversion function converting \'PR6066::A\' to its base class \'PR6066::B\' will never be used [-Wclass-conversion]"}
}
},
["warn_conv_to_self_not_used"]={
[j]={pc},
[k]=pc,
[g]="warn_conv_to_self_not_used",
[b]="conversion function converting %0 to itself will never be used",
[c]="conversion function converting A to itself will never be used",
[d]=m,
[e]="conversion function converting (.*?) to itself will never be used",
[f]=" \\[(?:\\-Werror,)?\\-Wclass\\-conversion[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{C,11174,"/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete\n/// the declaration of the given C++ conversion function. This routine\n/// is responsible for recording the conversion function in the C++\n/// class, if possible.\nDecl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {\n // ...\n if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared && Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)\n // ...\n else if (Conversion->size_overridden_methods() != 0)\n // ...\n else if (ConvType->isRecordType()) {\n // ...\n if (ConvType == ClassType)\n Diag(Conversion->getLocation(), diag::warn_conv_to_self_not_used) << ClassType;"}},
[l]={
["clang/test/SemaCXX/conversion-function.cpp"]={"clang/test/SemaCXX/conversion-function.cpp:63:3: warning: conversion function converting \'B\' to itself will never be used [-Wclass-conversion]","clang/test/SemaCXX/conversion-function.cpp:80:11: warning: conversion function converting \'DerivedB\' to itself will never be used [-Wclass-conversion]"}
}
},
["warn_conv_to_void_not_used"]={
[j]={pc},
[k]=pc,
[g]="warn_conv_to_void_not_used",
[b]="conversion function converting %0 to %1 will never be used",
[c]="conversion function converting A to B will never be used",
[d]=m,
[e]="conversion function converting (.*?) to (.*?) will never be used",
[f]=" \\[(?:\\-Werror,)?\\-Wclass\\-conversion[^\\]]*\\]",
[h]=n,
[a]={Hb,1237025389,Ib,Lb},
[i]={{C,11180,"/// ActOnConversionDeclarator - Called by ActOnDeclarator to complete\n/// the declaration of the given C++ conversion function. This routine\n/// is responsible for recording the conversion function in the C++\n/// class, if possible.\nDecl *Sema::ActOnConversionDeclarator(CXXConversionDecl *Conversion) {\n // ...\n if (Conversion->getTemplateSpecializationKind() != TSK_Undeclared && Conversion->getTemplateSpecializationKind() != TSK_ExplicitSpecialization)\n // ...\n else if (Conversion->size_overridden_methods() != 0)\n // ...\n else if (ConvType->isRecordType()) {\n // ...\n } else if (ConvType->isVoidType()) {\n Diag(Conversion->getLocation(), diag::warn_conv_to_void_not_used) << ClassType << ConvType;"}},
[l]={
["clang/test/SemaCXX/conversion-function.cpp"]={"clang/test/SemaCXX/conversion-function.cpp:62:3: warning: conversion function converting \'B\' to \'const void\' will never be used [-Wclass-conversion]"}
}
},
["warn_coroutine_handle_address_invalid_return_type"]={
[j]={"coroutine"},
[k]="coroutine",
[g]={{nil,t,"warn_coroutine_handle_address_invalid_return_type"}},
[b]={{nil,t,"return type of \'coroutine_handle<>::address should be \'void*\' (have %0) in order to get capability with existing async C API."}},
[c]={{nil,t,"return type of \'coroutine_handle<>::address should be \'void*\' (have A) in order to get capability with existing async C API."}},
[d]=m,
[e]="return type of \'coroutine_handle\\<\\>\\:\\:address should be \'void\\*\' \\(have (.*?)\\) in order to get capability with existing async C API\\.",
[f]=" \\[(?:\\-Werror,)?\\-Wcoroutine[^\\]]*\\]",
[h]={{nil,t,"Coroutines Issue"}},
[a]={ab,1582847864,Z,Y},
[i]={{"clang/lib/Sema/SemaCoroutine.cpp",350,"// See if return type is coroutine-handle and if so, invoke builtin coro-resume\n// on its address. This is to enable the support for coroutine-handle\n// returning await_suspend that results in a guaranteed tail call to the target\n// coroutine.\nstatic Expr *maybeTailCall(Sema &S, QualType RetType, Expr *E, SourceLocation Loc) {\n // ...\n // Check that the type of AddressExpr is void*\n if (!JustAddress->getType().getTypePtr()->isVoidPointerType())\n S.Diag(cast<CallExpr>(JustAddress)->getCalleeDecl()->getLocation(), diag::warn_coroutine_handle_address_invalid_return_type) << JustAddress->getType();"}},
[l]={
["clang/test/SemaCXX/coroutine_handle-address-return-type.cpp"]={"clang/test/SemaCXX/coroutine_handle-address-return-type.cpp:56:41: warning: return type of \'coroutine_handle<>::address should be \'void*\' (have \'coroutine_handle<task::promise_type> *\') in order to get capability with existing async C API. [-Wcoroutine]"}
}
},
["warn_coroutine_promise_unhandled_exception_required_with_exceptions"]={
[j]={"coroutine","coroutine-missing-unhandled-exception"},
[k]="coroutine-missing-unhandled-exception",
[g]={{nil,E,"warn_coroutine_promise_unhandled_exception_required_with_exceptions"}},
[b]={{nil,E,"%0 is required to declare the member \'unhandled_exception()\' when exceptions are enabled"}},
[c]={{nil,E,"A is required to declare the member \'unhandled_exception()\' when exceptions are enabled"}},
[d]=m,
[e]="(.*?) is required to declare the member \'unhandled_exception\\(\\)\' when exceptions are enabled",
[f]=" \\[(?:\\-Werror,)?\\-Wcoroutine\\-missing\\-unhandled\\-exception[^\\]]*\\]",
[h]={{nil,E,"Coroutines Issue"}},
[a]={"a9fdb346dbc6",1490229213,"[coroutines] Implement unhandled_exception changes.","[coroutines] Implement unhandled_exception changes.\n\nSummary:\nThis patch adopts the recent changes that renamed `set_exception(exception_pointer)` to `unhandled_exception()`. \n\nAdditionally `unhandled_exception()` is now required, and so an error is emitted when exceptions are enabled but the promise type does not provide the member.\nWhen exceptions are disabled a warning is emitted instead of an error, The warning notes that the `unhandled_exception()` function is required when exceptions are enabled.\n\nReviewers: rsmith, GorNishanov, aaron.ballman, majnemer\n\nReviewed By: GorNishanov\n\nSubscribers: mehdi_amini, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D30859\n\nllvm-svn: 298565"},
[i]={{"clang/lib/Sema/SemaCoroutine.cpp",1681,"bool CoroutineStmtBuilder::makeOnException() {\n // ...\n if (!lookupMember(S, \"unhandled_exception\", PromiseRecordDecl, Loc)) {\n auto DiagID = RequireUnhandledException ? diag::err_coroutine_promise_unhandled_exception_required : diag::warn_coroutine_promise_unhandled_exception_required_with_exceptions;"}},
[l]={
["clang/test/CodeGenCoroutines/coro-return.cpp"]={"clang/test/CodeGenCoroutines/coro-return.cpp:34:17: warning: \'promise_type\' is required to declare the member \'unhandled_exception()\' when exceptions are enabled [-Wcoroutine-missing-unhandled-exception]","clang/test/CodeGenCoroutines/coro-return.cpp:53:16: warning: \'promise_type\' is required to declare the member \'unhandled_exception()\' when exceptions are enabled [-Wcoroutine-missing-unhandled-exception]"}
}
},
["warn_correct_comment_command_name"]={
[j]={"documentation-pedantic","documentation-unknown-command"},
[k]="documentation-unknown-command",
[g]="warn_correct_comment_command_name",
[b]="unknown command tag name \'%0\'; did you mean \'%1\'?",
[c]="unknown command tag name \'A\'; did you mean \'B\'?",
[d]=m,
[e]="unknown command tag name \'(.*?)\'; did you mean \'(.*?)\'\\?",
[f]=" \\[(?:\\-Werror,)?\\-Wdocumentation\\-unknown\\-command[^\\]]*\\]",
[h]="Documentation Issue",
[a]={"6c7a16666dbb",1368040860,"documentation parsing. Patch to do typo correction for ","documentation parsing. Patch to do typo correction for \ndocumentation commands. Patch was reviewed, along with\ngreat suggestions for improvement, by Doug. \n// rdar://12381408\n\nllvm-svn: 181458"},
[i]={{"clang/lib/AST/CommentLexer.cpp",411,"void Lexer::lexCommentText(Token &T) {\n // ...\n case \'\\\\\':\n case \'@\': {\n // ...\n if (!Info) {\n if ((Info = Traits.getTypoCorrectCommandInfo(CommandName))) {\n // ...\n Diag(Loc, diag::warn_correct_comment_command_name) << FullRange << CommandName << CorrectedName << FixItHint::CreateReplacement(CommandRange, CorrectedName);"}},
[l]={
["clang/test/Sema/warn-documentation-fixits.cpp"]={"clang/test/Sema/warn-documentation-fixits.cpp:110:5: warning: unknown command tag name \'retur\'; did you mean \'return\'? [-Wdocumentation-unknown-command]","clang/test/Sema/warn-documentation-fixits.cpp:114:5: warning: unknown command tag name \'fooba\'; did you mean \'foobar\'? [-Wdocumentation-unknown-command]","clang/test/Sema/warn-documentation-fixits.cpp:123:5: warning: unknown command tag name \'encode\'; did you mean \'endcode\'? [-Wdocumentation-unknown-command]"}
}
},
["warn_cstruct_memaccess"]={
[j]={"nontrivial-memaccess","suspicious-memaccess"},
[k]="nontrivial-memaccess",
[g]={{nil,F,"warn_cstruct_memaccess"}},
[b]={{nil,F,"%select{destination for|source of|first operand of|second operand of}0 this %1 call is a pointer to record %2 that is not trivial to %select{primitive-default-initialize|primitive-copy}3"}},
[c]={{nil,F,{{"destination for","source of","first operand of","second operand of"}," this B call is a pointer to record C that is not trivial to ",{"primitive-default-initialize","primitive-copy"}}}},
[d]=m,
[e]="(?:destination for|source of|first operand of|second operand of) this (.*?) call is a pointer to record (.*?) that is not trivial to (?:primitive\\-default\\-initialize|primitive\\-copy)",
[f]=" \\[(?:\\-Werror,)?\\-Wnontrivial\\-memaccess[^\\]]*\\]",
[h]={{nil,F,n}},
[a]={"2be0441e770d",1523992421,"[Sema] Warn about memcpy\'ing non-trivial C structs.","[Sema] Warn about memcpy\'ing non-trivial C structs.\n\nIssue a warning when non-trivial C structs are copied or initialized by\ncalls to memset, bzero, memcpy, or memmove.\n\nrdar://problem/36124208\n\nDifferential Revision: https://reviews.llvm.org/D45310\n\nllvm-svn: 330202"},
[i]={{u,12587,"/// Check for dangerous or invalid arguments to memset().\n///\n/// This issues warnings on known problematic, dangerous or unspecified\n/// arguments to the standard \'memset\', \'memcpy\', \'memmove\', and \'memcmp\'\n/// function calls.\n///\n/// \\param Call The call expression to diagnose.\nvoid Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) {\n // ...\n for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {\n // ...\n if (const CXXRecordDecl *ContainedRD = getContainedDynamicClass(PointeeTy, IsContained)) {\n // ...\n } else if (PointeeTy.hasNonTrivialObjCLifetime() && BId != Builtin::BImemset)\n // ...\n else if (const auto *RT = PointeeTy->getAs<RecordType>()) {\n if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) && RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {\n DiagRuntimeBehavior(Dest->getExprLoc(), Dest, PDiag(diag::warn_cstruct_memaccess) << ArgIdx << FnName << PointeeTy << 0);"},{u,12593,"/// Check for dangerous or invalid arguments to memset().\n///\n/// This issues warnings on known problematic, dangerous or unspecified\n/// arguments to the standard \'memset\', \'memcpy\', \'memmove\', and \'memcmp\'\n/// function calls.\n///\n/// \\param Call The call expression to diagnose.\nvoid Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) {\n // ...\n for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {\n // ...\n if (const CXXRecordDecl *ContainedRD = getContainedDynamicClass(PointeeTy, IsContained)) {\n // ...\n } else if (PointeeTy.hasNonTrivialObjCLifetime() && BId != Builtin::BImemset)\n // ...\n else if (const auto *RT = PointeeTy->getAs<RecordType>()) {\n if ((BId == Builtin::BImemset || BId == Builtin::BIbzero) && RT->getDecl()->isNonTrivialToPrimitiveDefaultInitialize()) {\n // ...\n } else if ((BId == Builtin::BImemcpy || BId == Builtin::BImemmove) && RT->getDecl()->isNonTrivialToPrimitiveCopy()) {\n DiagRuntimeBehavior(Dest->getExprLoc(), Dest, PDiag(diag::warn_cstruct_memaccess) << ArgIdx << FnName << PointeeTy << 1);"}},
[l]={
["clang/test/SemaObjC/warn-nontrivial-struct-memaccess.m"]={"clang/test/SemaObjC/warn-nontrivial-struct-memaccess.m:34:10: warning: destination for this \'memset\' call is a pointer to record \'struct NonTrivial1\' that is not trivial to primitive-default-initialize [-Wnontrivial-memaccess]","clang/test/SemaObjC/warn-nontrivial-struct-memaccess.m:36:9: warning: destination for this \'bzero\' call is a pointer to record \'struct NonTrivial1\' that is not trivial to primitive-default-initialize [-Wnontrivial-memaccess]","clang/test/SemaObjC/warn-nontrivial-struct-memaccess.m:37:10: warning: destination for this \'memcpy\' call is a pointer to record \'struct NonTrivial1\' that is not trivial to primitive-copy [-Wnontrivial-memaccess]","clang/test/SemaObjC/warn-nontrivial-struct-memaccess.m:38:11: warning: destination for this \'memmove\' call is a pointer to record \'struct NonTrivial1\' that is not trivial to primitive-copy [-Wnontrivial-memaccess]"}
}
},
["warn_cstyle_param"]={
[j]={eb,"deprecated-declarations"},
[k]="deprecated-declarations",
[g]="warn_cstyle_param",
[b]="use of C-style parameters in Objective-C method declarations is deprecated",
[c]="use of C-style parameters in Objective-C method declarations is deprecated",
[d]=m,
[e]="use of C\\-style parameters in Objective\\-C method declarations is deprecated",
[f]=" \\[(?:\\-Werror,)?\\-Wdeprecated\\-declarations[^\\]]*\\]",
[h]=Gb,
[a]={"45337f53df65",1340304188,"objective-c: deprecated C-like parameters in Objective-C ","objective-c: deprecated C-like parameters in Objective-C \nmethod declarations.\n// rdar://11578353.\n\nllvm-svn: 158929"},
[i]={{"clang/lib/Parse/ParseObjc.cpp",1528,"/// objc-method-decl:\n/// objc-selector\n/// objc-keyword-selector objc-parmlist[opt]\n/// objc-type-name objc-selector\n/// objc-type-name objc-keyword-selector objc-parmlist[opt]\n///\n/// objc-keyword-selector:\n/// objc-keyword-decl\n/// objc-keyword-selector objc-keyword-decl\n///\n/// objc-keyword-decl:\n/// objc-selector \':\' objc-type-name objc-keyword-attributes[opt] identifier\n/// objc-selector \':\' objc-keyword-attributes[opt] identifier\n/// \':\' objc-type-name objc-keyword-attributes[opt] identifier\n/// \':\' objc-keyword-attributes[opt] identifier\n///\n/// objc-parmlist:\n/// objc-parms objc-ellipsis[opt]\n///\n/// objc-parms:\n/// objc-parms , parameter-declaration\n///\n/// objc-ellipsis:\n/// , ...\n///\n/// objc-keyword-attributes: [OBJC2]\n/// __attribute__((unused))\n///\nDecl *Parser::ParseObjCMethodDecl(SourceLocation mLoc, tok::TokenKind mType, tok::ObjCKeywordKind MethodImplKind, bool MethodDefinition) {\n // ...\n // Parse the (optional) parameter list.\n while (Tok.is(tok::comma)) {\n // ...\n if (!cStyleParamWarned) {\n Diag(Tok, diag::warn_cstyle_param);"}},
[l]={
["clang/test/SemaObjC/method-prototype-scope.m"]={"clang/test/SemaObjC/method-prototype-scope.m:10:19: warning: use of C-style parameters in Objective-C method declarations is deprecated [-Wdeprecated-declarations]","clang/test/SemaObjC/method-prototype-scope.m:26:19: warning: use of C-style parameters in Objective-C method declarations is deprecated [-Wdeprecated-declarations]"}
}
},
["warn_ctad_maybe_unsupported"]={
[j]={"ctad-maybe-unsupported"},
[k]="ctad-maybe-unsupported",
[g]={{nil,B,"warn_ctad_maybe_unsupported"}},
[b]={{nil,B,"%0 may not intend to support class template argument deduction"}},
[c]={{nil,B,"A may not intend to support class template argument deduction"}},
[d]=m,
[e]="(.*?) may not intend to support class template argument deduction",
[f]=" \\[(?:\\-Werror,)?\\-Wctad\\-maybe\\-unsupported[^\\]]*\\]",
[h]={{nil,B,n}},
[a]={"73b51ae160af",1547761464,"Add -Wctad-maybe-unsupported to diagnose CTAD on types with no user defined deduction guides.","Add -Wctad-maybe-unsupported to diagnose CTAD on types with no user defined deduction guides.\n\nSummary:\nSome style guides want to allow using CTAD only on types that \"opt-in\"; i.e. on types that are designed to support it and not just types that *happen* to work with it.\n\nThis patch implements the `-Wctad-maybe-unsupported` warning, which is off by default, which warns when CTAD is used on a type that does not define any deduction guides.\n\nThe following pattern can be used to suppress the warning in cases where the type intentionally doesn\'t define any deduction guides:\n\n```\nstruct allow_ctad_t;\n\ntemplate <class T>\nstruct TestSuppression {\n TestSuppression(T) {}\n};\nTestSuppression(allow_ctad_t)->TestSuppression<void>; // guides with incomplete parameter types are never considered.\n```\n\nReviewers: rsmith, james.dennett, gromer\n\nReviewed By: rsmith\n\nSubscribers: jdennett, Quuxplusone, lebedev.ri, cfe-commits\n\nDifferential Revision: https://reviews.llvm.org/D56731\n\nllvm-svn: 351484"},
[i]={{Rb,10917,"QualType Sema::DeduceTemplateSpecializationFromInitializer(TypeSourceInfo *TSInfo, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Inits, ParenListExpr *PL) {\n // ...\n // Warn if CTAD was used on a type that does not have any user-defined\n // deduction guides.\n if (!FoundDeductionGuide) {\n Diag(TSInfo->getTypeLoc().getBeginLoc(), diag::warn_ctad_maybe_unsupported) << TemplateName;"}},
[l]={
["clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp"]={"clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp:458:1: warning: \'NoExplicit\' may not intend to support class template argument deduction [-Wctad-maybe-unsupported]","clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp:477:1: warning: \'AmateurPair\' may not intend to support class template argument deduction [-Wctad-maybe-unsupported]","clang/test/SemaCXX/cxx1z-class-template-argument-deduction.cpp:486:1: warning: \'AmateurPair2\' may not intend to support class template argument deduction [-Wctad-maybe-unsupported]"}
}
},
["warn_ctor_parm_shadows_field"]={
[j]={"shadow-all","shadow-field-in-constructor"},
[k]="shadow-field-in-constructor",
[g]="warn_ctor_parm_shadows_field",
[b]="constructor parameter %0 shadows the field %1 of %2",
[c]="constructor parameter A shadows the field B of C",
[d]=m,
[e]="constructor parameter (.*?) shadows the field (.*?) of (.*?)",
[f]=" \\[(?:\\-Werror,)?\\-Wshadow\\-field\\-in\\-constructor[^\\]]*\\]",
[h]=n,
[a]={"f463a8a424e7",1461890263,"Avoid -Wshadow warnings about constructor parameters named after fields","Avoid -Wshadow warnings about constructor parameters named after fields\n\nUsually these parameters are used solely to initialize the field in the\ninitializer list, and there is no real shadowing confusion.\n\nThere is a new warning under -Wshadow called\n-Wshadow-field-in-constructor-modified. It attempts to find\nmodifications of such constructor parameters that probably intended to\nmodify the field.\n\nIt has some false negatives, though, so there is another warning group,\n-Wshadow-field-in-constructor, which always warns on this special case.\nFor users who just want the old behavior and don\'t care about these fine\ngrained groups, we have a new warning group called -Wshadow-all that\nactivates everything.\n\nFixes PR16088.\n\nReviewers: rsmith\n\nSubscribers: cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D18271\n\nllvm-svn: 267957"},
[i]={{H,2281,"void Sema::ActOnPopScope(SourceLocation Loc, Scope *S) {\n // ...\n for (auto *TmpD : S->decls()) {\n // ...\n if (ShadowI != ShadowingDecls.end()) {\n if (const auto *FD = dyn_cast<FieldDecl>(ShadowI->second)) {\n addDiagWithPrev(D->getLocation(), FD->getLocation(), PDiag(diag::warn_ctor_parm_shadows_field) << D << FD << FD->getParent());"}},
[l]={
["clang/test/SemaCXX/warn-shadow.cpp"]={"clang/test/SemaCXX/warn-shadow.cpp:62:9: warning: constructor parameter \'f1\' shadows the field \'f1\' of \'A\' [-Wshadow-field-in-constructor]","clang/test/SemaCXX/warn-shadow.cpp:62:17: warning: constructor parameter \'f2\' shadows the field \'f2\' of \'A\' [-Wshadow-field-in-constructor]","clang/test/SemaCXX/warn-shadow.cpp:62:25: warning: constructor parameter \'f3\' shadows the field \'f3\' of \'A\' [-Wshadow-field-in-constructor]","clang/test/SemaCXX/warn-shadow.cpp:62:33: warning: constructor parameter \'f4\' shadows the field \'f4\' of \'A\' [-Wshadow-field-in-constructor]"}
}
}
};