Module:ClangDiags/DiagsLongData9: Difference between revisions

local a="regex1";

local c="source";

local d="commit";

local e="category_hist";

local f="regex3";

local g="regex2";

local h="id_hist";

local i="hierarchical_hist";

local k="";

local l="maingroup";

local m="groups";

local n="Semantic Issue";

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

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

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

local w="13.0";

local x="15.0";

local y="12.0";

local z="11.0";

local A="Lexical or Preprocessor Issue";

local B="read of";

local C="8.0";

local D="6.0";

local E="microsoft";

local F="Parse Issue";

local G="assignment to";

local I="decrement of";

local K="b1c4d5507fad";

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

local M="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 N="clang/lib/Sema/SemaTemplate.cpp";

local O="16.0";

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

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

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

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

local T="5a8987ca5113";

local U="14.0";

local V="gnu";

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

local Z="5.0";

local ab="typeid applied to";

local cb="member call on";

local db="dynamic_cast of";

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

local fb="microsoft-template";

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

local ib="c++20-extensions";

local jb=" \\[(?:\\-Werror,)?\\-Wc\\+\\+11\\-extensions[^\\]]*\\]";

local kb="CL4";

local lb="clang/lib/AST/Interp/Interp.cpp";

local mb="7.0";

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

local sb="PR20356: Fix all Sema warnings with mismatched ext_/warn_ versus\nExtWarn/Warnings. Mostly the name of the warning was changed to match the\nsemantics, but in the PR20356 cases, the warning was about valid code, so the\ndiagnostic was changed from ExtWarn to Warning instead.\n\nllvm-svn: 213443";

local tb="1b98ccc4e957";

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

local wb="destruction of";

local xb="For P0784R7: Add support for dynamic allocation with new / delete during\nconstant evaluation.\n\nllvm-svn: 373036";

local yb="For P0784R7: Add support for dynamic allocation with new / delete during";

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

local Bb="c++1z-extensions";

local Cb="da1b4347e41a";

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

local Eb="converting A to type B";

local Fb="casting between types";

local Gb="returning from function with different return type";

local Hb="clang/lib/Sema/SemaExceptionSpec.cpp";

local Ib="returning A from a function with result type B";

local Jb="passing to parameter of different type";

local Kb="initializing A with an expression of type B";

local Mb="assigning to different types";

local Nb="assigning to A from B";

local Ob="converting between types";

local Pb="initializing with expression of different type";

local Qb="sending to parameter of different type";

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

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

local Tb="sending A to parameter of type B";

local Ub="casting A to type B";

local Vb="microsoft-exception-spec";

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

local Xb="clang/lib/Lex/LiteralSupport.cpp";

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

local Zb="function";

local ac="variable";

local bc=" \\[(?:\\-Werror,)?\\-Wc\\+\\+20\\-extensions[^\\]]*\\]";

local cc="(?: \\[(?:\\-Werror)?[^\\]]*\\])?";

local dc="Implement P2361 Unevaluated string literals";

local ec=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-template[^\\]]*\\]";

local fc="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 gc="c++2a-extensions";

local hc=" ";

local ic="implicit";

local kc="95f50964fbf5";

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

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

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

local oc="construction of";

local pc="clang/lib/Sema/SemaAvailability.cpp";

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

local sc="unknown-pragmas";

local uc="3da88fac5416";

local vc="[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";

local wc="C++1y: support simple variable assignments in constexpr functions.";

local xc="[clang] Add no_builtin attribute";

local yc="C++1y: support simple variable assignments in constexpr functions.\n\nllvm-svn: 180603";

local Ac="clang/test/SemaCXX/constant-expression-cxx2a.cpp";

local Cc="c++11-narrowing";

local Dc="clang/test/CXX/expr/expr.const/p2-0x.cpp";

local Ec="c++11-compat-pedantic";

local Fc="c++11-compat";

local Gc="ARC Casting Rules";

local Hc="31168b077c36";

local Ic="Automatic Reference Counting.";

local Jc="missing-declarations";

local Kc="11.1";

local Lc="variadic-macros";

local Mc="pointer-arith";

local Nc="Support warn_unused_result on typedefs";

local Oc="clang/lib/Sema/SemaConcept.cpp";

local Pc="69350e569dc4";

local Qc="[C++20][Modules][3/8] Initial handling for module partitions.";

local Rc="[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";

local Uc="Refine r251469 to give better (and more localizable) diagnostics\nfor all the reasons that ARC makes things implicitly unavailable.\n\nllvm-svn: 251496";

local Wc="[C++2a] Add __builtin_bit_cast, used to implement std::bit_cast\n\nThis commit adds a new builtin, __builtin_bit_cast(T, v), which performs a\nbit_cast from a value v to a type T. This expression can be evaluated at\ncompile time under specific circumstances.\n\nThe compile time evaluation currently doesn\'t support bit-fields, but I\'m\nplanning on fixing this in a follow up (some of the logic for figuring this out\nis in CodeGen). I\'m also planning follow-ups for supporting some more esoteric\ntypes that the constexpr evaluator supports, as well as extending\n__builtin_memcpy constexpr evaluation to use the same infrastructure.\n\nrdar://44987528\n\nDifferential revision: https://reviews.llvm.org/D62825\n\nllvm-svn: 364954";

local Xc="c++0x-compat";

local Yc="temporary";

local Zc="7c11da0cfd33";

local ad="[clang] New __attribute__((__clang_arm_mve_alias)).";

local bd="Support warn_unused_result on typedefs\n\nWhile it\'s not as robust as using the attribute on enums/classes (the\ntype information may be lost through a function pointer, a declaration\nor use of the underlying type without using the typedef, etc) but I\nthink there\'s still value in being able to attribute a typedef and have\nall return types written with that typedef pick up the\nwarn_unused_result behavior.\n\nSpecifically I\'d like to be able to annotate LLVMErrorRef (a wrapper for\nllvm::Error used in the C API - the underlying type is a raw pointer, so\nit can\'t be attributed itself) to reduce the chance of unhandled errors.\n\nDifferential Revision: https://reviews.llvm.org/D102122";

local cd="clang/test/SemaCXX/constexpr-value-init.cpp:4:21: note: read of object outside its lifetime is not allowed in a constant expression";

local fd="[C++2a] Add __builtin_bit_cast, used to implement std::bit_cast";

local gd="Refine r251469 to give better (and more localizable) diagnostics";

local hd="c6af8c606dae";

local id="ARC Restrictions";

local jd="eee944e7f9e6";

local kd="[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";

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

[m]={V,"gnu-statement-expression","gnu-statement-expression-from-macro-expansion",t},

[l]="gnu-statement-expression-from-macro-expansion",

[h]={{nil,x,"ext_gnu_statement_expr_macro"}},

[b]={{nil,x,"use of GNU statement expression extension from macro expansion"}},

[i]={{nil,x,"use of GNU statement expression extension from macro expansion"}},

[a]=o,

[g]="use of GNU statement expression extension from macro expansion",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-statement\\-expression\\-from\\-macro\\-expansion[^\\]]*\\]",

[e]={{nil,x,F}},

[d]={"7689c7fc9e08",1653629944,"Create specialization of -Wgnu-statement-expression for expressions found in macros.","Create specialization of -Wgnu-statement-expression for expressions found in macros.\n\n-Wgnu-statement-expression currently warns for both direct source uses of statement expressions but also macro expansions; since they may be used by macros to avoid multiple evaluation of macro arguments, engineers might want to suppress warnings when statement expressions are expanded from macros but see them if introduced directly in source code.\n\nDifferential Revision: https://reviews.llvm.org/D126522"},

[c]={{"clang/lib/Parse/ParseExpr.cpp",2932,"/// ParseParenExpression - This parses the unit that starts with a \'(\' token,\n/// based on what is allowed by ExprType.  The actual thing parsed is returned\n/// in ExprType. If stopIfCastExpr is true, it will only return the parsed type,\n/// not the parsed cast-expression.\n///\n/// \\verbatim\n///      primary-expression: [C99 6.5.1]\n///        \'(\' expression \')\'\n/// [GNU]  \'(\' compound-statement \')\'      (if !ParenExprOnly)\n///      postfix-expression: [C99 6.5.2]\n///        \'(\' type-name \')\' \'{\' initializer-list \'}\'\n///        \'(\' type-name \')\' \'{\' initializer-list \',\' \'}\'\n///      cast-expression: [C99 6.5.4]\n///        \'(\' type-name \')\' cast-expression\n/// [ARC]  bridged-cast-expression\n/// [ARC] bridged-cast-expression:\n///        (__bridge type-name) cast-expression\n///        (__bridge_transfer type-name) cast-expression\n///        (__bridge_retained type-name) cast-expression\n///      fold-expression: [C++1z]\n///        \'(\' cast-expression fold-operator \'...\' \')\'\n///        \'(\' \'...\' fold-operator cast-expression \')\'\n///        \'(\' cast-expression fold-operator \'...\'\n///                fold-operator cast-expression \')\'\n/// [OPENMP] Array shaping operation\n///      \'(\' \'[\' expression \']\' { \'[\' expression \']\' } cast-expression\n/// \\endverbatim\nExprResult Parser::ParseParenExpression(ParenParseOption &ExprType, bool stopIfCastExpr, bool isTypeCast, ParsedType &CastTy, SourceLocation &RParenLoc) {\n  // ...\n  // None of these cases should fall through with an invalid Result\n  // unless they\'ve already reported an error.\n  if (ExprType >= CompoundStmt && Tok.is(tok::l_brace)) {\n    Diag(Tok, OpenLoc.isMacroID() ? diag::ext_gnu_statement_expr_macro : diag::ext_gnu_statement_expr);"}},

[m]={V,"gnu-pointer-arith",t,Mc},

[l]="gnu-pointer-arith",

[h]="ext_gnu_subscript_void_type",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-pointer\\-arith[^\\]]*\\]",

[e]=n,

[d]={"4cc3f296a907",1309192347,"Cleanup a fixme by using a specific diagnostic for subscripting","Cleanup a fixme by using a specific diagnostic for subscripting\na pointer to void.\n\nllvm-svn: 133912"},

[c]={{u,5981,"ExprResult Sema::CreateBuiltinArraySubscriptExpr(Expr *Base, SourceLocation LLoc, Expr *Idx, SourceLocation RLoc) {\n  // ...\n  if (ResultType->isVoidType() && !getLangOpts().CPlusPlus) {\n    // ...\n    Diag(LLoc, diag::ext_gnu_subscript_void_type) << BaseExpr->getSourceRange();"}},

[m]={V,"gnu-pointer-arith",t,Mc},

[l]="gnu-pointer-arith",

[h]="ext_gnu_void_ptr",

[i]={{nil,nil,{"arithmetic on",{" a",k}," pointer",{k,"s"}," to void is a GNU extension"}}},

[a]=o,

[g]="arithmetic on(?: a|) pointer(?:|s) to void is a GNU extension",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-pointer\\-arith[^\\]]*\\]",

[e]=n,

[d]={T,1237025389,S,R},

[c]={{u,11440,"static void diagnoseArithmeticOnTwoVoidPointers(Sema &S, SourceLocation Loc, Expr *LHSExpr, Expr *RHSExpr) { S.Diag(Loc, S.getLangOpts().CPlusPlus ? diag::err_typecheck_pointer_arith_void_type : diag::ext_gnu_void_ptr) << 1 /* two pointers */ << LHSExpr->getSourceRange() << RHSExpr->getSourceRange(); }"},{u,11453,"static void diagnoseArithmeticOnVoidPointer(Sema &S, SourceLocation Loc, Expr *Pointer) { S.Diag(Loc, S.getLangOpts().CPlusPlus ? diag::err_typecheck_pointer_arith_void_type : diag::ext_gnu_void_ptr) << 0 /* one pointer */ << Pointer->getSourceRange(); }"}},

[m]={E,"microsoft-goto"},

[l]="microsoft-goto",

[h]="ext_goto_into_protected_scope",

[f]=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-goto[^\\]]*\\]",

[e]=n,

[d]={tb,1405733957,ub,sb},

[c]={{"clang/lib/Sema/JumpDiagnostics.cpp",667,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    // ...\n    // With a goto,\n    if (GotoStmt *GS = dyn_cast<GotoStmt>(Jump)) {\n      // The label may not have a statement if it\'s coming from inline MS ASM.\n      if (GS->getLabel()->getStmt()) {\n        CheckJump(GS, GS->getLabel()->getStmt(), GS->getGotoLoc(), diag::err_goto_into_protected_scope, diag::ext_goto_into_protected_scope, diag::warn_cxx98_compat_goto_into_protected_scope);"},{"clang/lib/Sema/JumpDiagnostics.cpp",695,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    // ...\n    // We only get indirect gotos here when they have a constant target.\n    if (IndirectGotoStmt *IGS = dyn_cast<IndirectGotoStmt>(Jump)) {\n      // ...\n      CheckJump(IGS, Target->getStmt(), IGS->getGotoLoc(), diag::err_goto_into_protected_scope, diag::ext_goto_into_protected_scope, diag::warn_cxx98_compat_goto_into_protected_scope);"}},

[m]={"c99-extensions",t},

[l]="c99-extensions",

[h]="ext_hex_constant_invalid",

[f]=" \\[(?:\\-Werror,)?\\-Wc99\\-extensions[^\\]]*\\]",

[e]=A,

[d]={"560a3579b29a",1457130726,"Update diagnostics now that hexadecimal literals look likely to be part of C++17.","Update diagnostics now that hexadecimal literals look likely to be part of C++17.\n\nllvm-svn: 262753"},

[c]={{Xb,1330,"/// ParseNumberStartingWithZero - This method is called when the first character\n/// of the number is found to be a zero.  This means it is either an octal\n/// number (like \'04\') or a hex number (\'0x123a\') a binary number (\'0b1010\') or\n/// a floating point number (01239.123e4).  Eat the prefix, determining the\n/// radix etc.\nvoid NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {\n  // ...\n  // Handle a hex number like 0x1234.\n  if ((c1 == \'x\' || c1 == \'X\') && (isHexDigit(s[1]) || s[1] == \'.\')) {\n    // ...\n    // A binary exponent can appear with or with a \'.\'. If dotted, the\n    // binary exponent is required.\n    if (*s == \'p\' || *s == \'P\') {\n      // ...\n      if (!LangOpts.HexFloats)\n        Diags.Report(TokLoc, LangOpts.CPlusPlus ? diag::ext_hex_literal_invalid : diag::ext_hex_constant_invalid);"}},

[m]={Y,Bb,t},

[l]=Y,

[h]="ext_hex_literal_invalid",

[i]="hexadecimal floating literals are a C++1z feature",

[a]=o,

[g]="hexadecimal floating literals are a C\\+\\+17 feature",

[f]=zb,

[e]=A,

[d]={"560a3579b29a",1457130726,"Update diagnostics now that hexadecimal literals look likely to be part of C++17.","Update diagnostics now that hexadecimal literals look likely to be part of C++17.\n\nllvm-svn: 262753"},

[c]={{Xb,1329,"/// ParseNumberStartingWithZero - This method is called when the first character\n/// of the number is found to be a zero.  This means it is either an octal\n/// number (like \'04\') or a hex number (\'0x123a\') a binary number (\'0b1010\') or\n/// a floating point number (01239.123e4).  Eat the prefix, determining the\n/// radix etc.\nvoid NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {\n  // ...\n  // Handle a hex number like 0x1234.\n  if ((c1 == \'x\' || c1 == \'X\') && (isHexDigit(s[1]) || s[1] == \'.\')) {\n    // ...\n    // A binary exponent can appear with or with a \'.\'. If dotted, the\n    // binary exponent is required.\n    if (*s == \'p\' || *s == \'P\') {\n      // ...\n      if (!LangOpts.HexFloats)\n        Diags.Report(TokLoc, LangOpts.CPlusPlus ? diag::ext_hex_literal_invalid : diag::ext_hex_constant_invalid);"}},

[m]={"hlsl-extensions"},

[l]="hlsl-extensions",

[h]={{nil,x,"ext_hlsl_access_specifiers"}},

[b]={{nil,x,"access specifiers are a clang HLSL extension"}},

[i]={{nil,x,"access specifiers are a clang HLSL extension"}},

[a]=o,

[g]="access specifiers are a clang HLSL extension",

[f]=" \\[(?:\\-Werror,)?\\-Whlsl\\-extensions[^\\]]*\\]",

[e]={{nil,x,k}},

[d]={"0d6b574b8717",1651158800,"[HLSL] Adjust access specifier behavior","[HLSL] Adjust access specifier behavior\n\nHLSL doesn\'t support access specifiers. This change has two components:\n\n1) Make default access for classes public\n2) Diagnose the use of access specifiers as a clang HLSL extension\n\nAs long as the default behavior for access specifiers matches HLSL,\nallowing them to be used doesn\'t cause sourece incompatability with\nvalid code. As such enabling them as a clang extension seems like a\nreasonable approach.\n\nFixes #55124\n\nReviewed By: aaron.ballman\n\nDifferential Revision: https://reviews.llvm.org/D124487"},

[c]={{Q,2271,"/// ParseBaseSpecifier - Parse a C++ base-specifier. A base-specifier is\n/// one entry in the base class list of a class specifier, for example:\n///    class foo : public bar, virtual private baz {\n/// \'public bar\' and \'virtual private baz\' are each base-specifiers.\n///\n///      base-specifier: [C++ class.derived]\n///        attribute-specifier-seq[opt] base-type-specifier\n///        attribute-specifier-seq[opt] \'virtual\' access-specifier[opt]\n///                base-type-specifier\n///        attribute-specifier-seq[opt] access-specifier \'virtual\'[opt]\n///                base-type-specifier\nBaseResult Parser::ParseBaseSpecifier(Decl *ClassDecl) {\n  // ...\n  if (Access != AS_none) {\n    // ...\n    if (getLangOpts().HLSL)\n      Diag(Tok.getLocation(), diag::ext_hlsl_access_specifiers);"},{Q,3378,"Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(AccessSpecifier &AS, ParsedAttributes &AccessAttrs, DeclSpec::TST TagType, Decl *TagDecl) {\n  // ...\n  case tok::kw_public:\n  case tok::kw_protected: {\n    if (getLangOpts().HLSL)\n      Diag(Tok.getLocation(), diag::ext_hlsl_access_specifiers);"}},

[m]={t},

[l]=t,

[h]="ext_ident_list_in_param",

[i]="type-less parameter names in function declaration",

[a]=o,

[g]="type\\-less parameter names in function declaration",

[f]=X,

[e]=F,

[d]={K,1236199783,L,M},

[c]={{Ab,7218,"/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator\n/// we found a K&R-style identifier list instead of a typed parameter list.\n///\n/// After returning, ParamInfo will hold the parsed parameters.\n///\n///      identifier-list: [C99 6.7.5]\n///        identifier\n///        identifier-list \',\' identifier\n///\nvoid Parser::ParseFunctionDeclaratorIdentifierList(Declarator &D, SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo) {\n  // ...\n  // If there was no identifier specified for the declarator, either we are in\n  // an abstract-declarator, or we are in a parameter declarator which was found\n  // to be abstract.  In abstract-declarators, identifier lists are not valid:\n  // diagnose this.\n  if (!D.getIdentifier())\n    Diag(Tok, diag::ext_ident_list_in_param);"}}

[m]={V,"gnu-imaginary-constant",t},

[l]="gnu-imaginary-constant",

[h]="ext_imaginary_constant",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-imaginary\\-constant[^\\]]*\\]",

[e]={{nil,D,n},{Z,nil,A}},

[d]={K,1236199783,L,M},

[c]={{u,4279,"ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {\n  // ...\n  // If this is an imaginary literal, create the ImaginaryLiteral wrapper.\n  if (Literal.isImaginary) {\n    // ...\n    Diag(Tok.getLocation(), diag::ext_imaginary_constant);"}},

[m]={"implicit-exception-spec-mismatch"},

[l]="implicit-exception-spec-mismatch",

[h]="ext_implicit_exception_spec_mismatch",

[i]={{nil,nil,{"function previously declared with an ",{"explicit",ic}," exception specification redeclared with an ",{ic,"explicit"}," exception specification"}}},

[a]=o,

[g]="function previously declared with an (?:explicit|implicit) exception specification redeclared with an (?:implicit|explicit) exception specification",

[f]=" \\[(?:\\-Werror,)?\\-Wimplicit\\-exception\\-spec\\-mismatch[^\\]]*\\]",

[e]=n,

[d]={"66f3ac9d2197",1350721611,"Rework implementation of DR1492: Apply the resolution to operator delete too,","Rework implementation of DR1492: Apply the resolution to operator delete too,\nsince it also has an implicit exception specification. Downgrade the error to\nan extwarn, since at least for operator delete, system headers like to declare\nit as \'noexcept\' whereas the implicit definition does not have an explicit\nexception specification. Move the exception specification for user-declared\n\'operator delete\' functions from the type-as-written into the type, to reflect\nreality and to allow us to detect whether there was an implicit exception spec\nor not.\n\nllvm-svn: 166372"},

[c]={{Hb,340,"bool Sema::CheckEquivalentExceptionSpec(FunctionDecl *Old, FunctionDecl *New) {\n  // ...\n  // Check the types as written: they must match before any exception\n  // specification adjustment is applied.\n  if (!CheckEquivalentExceptionSpecImpl(*this, PDiag(DiagID), PDiag(diag::note_previous_declaration), Old->getType()->getAs<FunctionProtoType>(), Old->getLocation(), New->getType()->getAs<FunctionProtoType>(), New->getLocation(), &MissingExceptionSpecification, &MissingEmptyExceptionSpecification,\n    // ...\n    // C++11 [except.spec]p4 [DR1492]:\n    //  If a declaration of a function has an implicit\n    //  exception-specification, other declarations of the function shall\n    //  not specify an exception-specification.\n    if (getLangOpts().CPlusPlus11 && getLangOpts().CXXExceptions && hasImplicitExceptionSpec(Old) != hasImplicitExceptionSpec(New)) {\n      Diag(New->getLocation(), diag::ext_implicit_exception_spec_mismatch) << hasImplicitExceptionSpec(Old);"}},

[m]={kb,qb,ic,tc,pb},

[l]=tc,

[h]={{nil,x,"ext_implicit_function_decl_c99"}},

[b]={{nil,x,"call to undeclared function %0; ISO C99 and later do not support implicit function declarations"}},

[i]={{nil,x,"call to undeclared function A; ISO C99 and later do not support implicit function declarations"}},

[a]=P,

[g]="call to undeclared function (.*?); ISO C99 and later do not support implicit function declarations",

[f]=" \\[[^\\]]*\\-Wimplicit\\-function\\-declaration[^\\]]*\\]",

[e]={{nil,x,n}},

[d]={dd,1620530452,Nc,bd},

[c]={{v,16053,"/// 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  // ...\n  // OpenCL v2.0 s6.9.u - Implicit function declaration is not supported.\n  else if (getLangOpts().C99)\n    diag_id = diag::ext_implicit_function_decl_c99;"}},

[m]={kb,qb,ic,tc,pb},

[l]=tc,

[h]="ext_implicit_lib_function_decl",

[i]="implicitly declaring library function \'A\' with type B",

[a]=o,

[g]="implicitly declaring library function \'(.*?)\' with type (.*?)",

[f]=" \\[(?:\\-Werror,)?\\-Wimplicit\\-function\\-declaration[^\\]]*\\]",

[e]=n,

[d]={K,1236199783,L,M},

[c]={{v,2468,"/// LazilyCreateBuiltin - The specified Builtin-ID was first used at\n/// file scope.  lazily create a decl for it. ForRedeclaration is true\n/// if we\'re creating this built-in in anticipation of redeclaring the\n/// built-in.\nNamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc) {\n  // ...\n  if (!ForRedeclaration && (Context.BuiltinInfo.isPredefinedLibFunction(ID) || Context.BuiltinInfo.isHeaderDependentFunction(ID))) {\n    Diag(Loc, LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99 : diag::ext_implicit_lib_function_decl) << Context.BuiltinInfo.getName(ID) << R;"}},

[m]={kb,qb,ic,tc,pb},

[l]=tc,

[h]={{nil,x,"ext_implicit_lib_function_decl_c99"}},

[b]={{nil,x,"call to undeclared library function \'%0\' with type %1; ISO C99 and later do not support implicit function declarations"}},

[i]={{nil,x,"call to undeclared library function \'A\' with type B; ISO C99 and later do not support implicit function declarations"}},

[a]=P,

[g]="call to undeclared library function \'(.*?)\' with type (.*?); ISO C99 and later do not support implicit function declarations",

[f]=" \\[[^\\]]*\\-Wimplicit\\-function\\-declaration[^\\]]*\\]",

[e]={{nil,x,n}},

[d]={dd,1620530452,Nc,bd},

[c]={{v,2467,"/// LazilyCreateBuiltin - The specified Builtin-ID was first used at\n/// file scope.  lazily create a decl for it. ForRedeclaration is true\n/// if we\'re creating this built-in in anticipation of redeclaring the\n/// built-in.\nNamedDecl *Sema::LazilyCreateBuiltin(IdentifierInfo *II, unsigned ID, Scope *S, bool ForRedeclaration, SourceLocation Loc) {\n  // ...\n  if (!ForRedeclaration && (Context.BuiltinInfo.isPredefinedLibFunction(ID) || Context.BuiltinInfo.isHeaderDependentFunction(ID))) {\n    Diag(Loc, LangOpts.C99 ? diag::ext_implicit_lib_function_decl_c99 : diag::ext_implicit_lib_function_decl) << Context.BuiltinInfo.getName(ID) << R;"}},

[m]={ib,gc},

[l]=ib,

[h]={{nil,O,"ext_implicit_typename"}},

[b]={{nil,O,"missing \'typename\' prior to dependent type name %0%1; implicit \'typename\' is a C++20 extension"}},

[i]={{nil,O,"missing \'typename\' prior to dependent type name AB; implicit \'typename\' is a C++20 extension"}},

[a]=o,

[g]="missing \'typename\' prior to dependent type name (.*?)(.*?); implicit \'typename\' is a C\\+\\+20 extension",

[f]=bc,

[e]={{nil,O,n}},

[d]={kc,1625925174,dc,fc},

[c]={{v,374,"/// If the identifier refers to a type name within this scope,\n/// return the declaration of that type.\n///\n/// This routine performs ordinary name lookup of the identifier II\n/// within the given scope, with optional C++ scope specifier SS, to\n/// determine whether the name refers to a type. If so, returns an\n/// opaque pointer (actually a QualType) corresponding to that\n/// type. Otherwise, returns NULL.\nParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS, bool isClassName, bool HasTrailingDot, ParsedType ObjectTypePtr, bool IsCtorOrDtorName, bool WantNontrivialTypeSourceInfo, bool IsClassTemplateDeductionContext, ImplicitTypenameContext AllowImplicitTypename, IdentifierInfo **CorrectedII) {\n  // ...\n  if (ObjectTypePtr) {\n  // ...\n  } else if (SS && SS->isNotEmpty()) {\n    // ...\n    if (!LookupCtx) {\n      if (isDependentScopeSpecifier(*SS)) {\n        // ...\n        if (IsImplicitTypename) {\n          // ...\n          if (getLangOpts().CPlusPlus20)\n          // ...\n          else\n            Diag(QualifiedLoc, diag::ext_implicit_typename) << SS->getScopeRep() << II.getName() << FixItHint::CreateInsertion(QualifiedLoc, \"typename \");"},{N,4149,"TypeResult Sema::ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, bool IsCtorOrDtorName, bool IsClassName, ImplicitTypenameContext AllowImplicitTypename) {\n  // ...\n  if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {\n    // ...\n    // C++ [temp.res]p3:\n    //  A qualified-id that refers to a type and in which the\n    //  nested-name-specifier depends on a template-parameter (14.6.2)\n    //  shall be prefixed by the keyword typename to indicate that the\n    //  qualified-id denotes a type, forming an\n    //  elaborated-type-specifier (7.1.5.3).\n    if (!LookupCtx && isDependentScopeSpecifier(SS)) {\n      // C++2a relaxes some of those restrictions in [temp.res]p5.\n      if (AllowImplicitTypename == ImplicitTypenameContext::Yes) {\n        if (getLangOpts().CPlusPlus20)\n        // ...\n        else\n          Diag(SS.getBeginLoc(), diag::ext_implicit_typename) << SS.getScopeRep() << TemplateII->getName() << FixItHint::CreateInsertion(SS.getBeginLoc(), \"typename \");"}},

[m]={V,"gnu-static-float-init","static-float-init"},

[l]="gnu-static-float-init",

[h]="ext_in_class_initializer_float_type",

[i]="in-class initializer for static data member of type A is a GNU extension",

[a]=o,

[g]="in\\-class initializer for static data member of type (.*?) is a GNU extension",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-static\\-float\\-init[^\\]]*\\]",

[e]=n,

[d]={"db76892e72e4",1284160882,"Support in-class initialization of static const floating-point data members.","Support in-class initialization of static const floating-point data members.\n\nllvm-svn: 113663"},

[c]={{v,13521,"/// 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->isLocalVarDecl()) {\n  // ...\n  } else if (VDecl->isStaticDataMember() && !VDecl->isInline() && VDecl->getLexicalDeclContext()->isRecord()) {\n    // ...\n    // Do nothing on dependent types.\n    if (DclT->isDependentType()) {\n    // ...\n    } else if (VDecl->isConstexpr()) {\n    // ...\n    } else if (!DclT.isConstQualified()) {\n    // ...\n    } else if (DclT->isIntegralOrEnumerationType()) {\n    // ...\n    } else if (DclT->isFloatingType()) { // also permits complex, which is ok\n      // In C++98, this is a GNU extension. In C++11, it is not, but we support\n      // it anyway and provide a fixit to add the \'constexpr\'.\n      if (getLangOpts().CPlusPlus11) {\n      // ...\n      } else {\n        Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type) << DclT << Init->getSourceRange();"}},

[m]={"static-float-init"},

[l]="static-float-init",

[h]="ext_in_class_initializer_float_type_cxx11",

[i]="in-class initializer for static data member of type A requires \'constexpr\' specifier",

[a]=P,

[g]="in\\-class initializer for static data member of type (.*?) requires \'constexpr\' specifier",

[f]=" \\[[^\\]]*\\-Wstatic\\-float\\-init[^\\]]*\\]",

[e]=n,

[d]={"cf656385ea2d",1359087736,"Sync \'in class initialization of static const double\' extension up with GCC,","Sync \'in class initialization of static const double\' extension up with GCC,\nand split it out of -Wgnu into its own warning flag.\n\n * In C++11, this is now a hard error (GCC has no extension here in C++11 mode).\n  The error can be disabled with -Wno-static-float-init, and has a fixit to\n  add \'constexpr\'.\n\n * In C++98, this is still an ExtWarn, but is now controlled by\n  -Wstatic-float-init as well as -Wgnu.\n\nllvm-svn: 173414"},

[c]={{v,13515,"/// 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->isLocalVarDecl()) {\n  // ...\n  } else if (VDecl->isStaticDataMember() && !VDecl->isInline() && VDecl->getLexicalDeclContext()->isRecord()) {\n    // ...\n    // Do nothing on dependent types.\n    if (DclT->isDependentType()) {\n    // ...\n    } else if (VDecl->isConstexpr()) {\n    // ...\n    } else if (!DclT.isConstQualified()) {\n    // ...\n    } else if (DclT->isIntegralOrEnumerationType()) {\n    // ...\n    } else if (DclT->isFloatingType()) { // also permits complex, which is ok\n      // In C++98, this is a GNU extension. In C++11, it is not, but we support\n      // it anyway and provide a fixit to add the \'constexpr\'.\n      if (getLangOpts().CPlusPlus11) {\n        Diag(VDecl->getLocation(), diag::ext_in_class_initializer_float_type_cxx11) << DclT << Init->getSourceRange();"}},

[m]={V,"gnu-folding-constant",t},

[l]="gnu-folding-constant",

[h]="ext_in_class_initializer_non_constant",

[i]="in-class initializer for static data member is not a constant expression; folding it to a constant is a GNU extension",

[a]=o,

[g]="in\\-class initializer for static data member is not a constant expression; folding it to a constant is a GNU extension",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-folding\\-constant[^\\]]*\\]",

[e]=n,

[d]={"9925ec8bf446",1308030389,"fix rdar://9204520 - Accept int(0.85 * 10) as an initializer in a class member","fix rdar://9204520 - Accept int(0.85 * 10) as an initializer in a class member\nas an extension.\n\nllvm-svn: 132980"},

[c]={{v,13499,"/// 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->isLocalVarDecl()) {\n  // ...\n  } else if (VDecl->isStaticDataMember() && !VDecl->isInline() && VDecl->getLexicalDeclContext()->isRecord()) {\n    // ...\n    // Do nothing on dependent types.\n    if (DclT->isDependentType()) {\n    // ...\n    } else if (VDecl->isConstexpr()) {\n    // ...\n    } else if (!DclT.isConstQualified()) {\n    // ...\n    } else if (DclT->isIntegralOrEnumerationType()) {\n      // ...\n      if (getLangOpts().CPlusPlus11 && DclT.isVolatileQualified())\n      // ...\n      else if (Init->isValueDependent())\n      // ...\n      else if (Init->isIntegerConstantExpr(Context, &Loc))\n      // ...\n      else if (Init->getType()->isScopedEnumeralType() && Init->isCXX11ConstantExpr(Context))\n      // ...\n      else if (Init->isEvaluatable(Context)) {\n        // ...\n        Diag(Loc, diag::ext_in_class_initializer_non_constant) << Init->getSourceRange();"}},

[m]={E,Vb},

[l]=Vb,

[h]="ext_incomplete_in_exception_spec",

[i]={{nil,nil,{{k,"pointer to ","reference to "},"incomplete type B is not allowed in exception specification"}}},

[a]=o,

[g]="(?:|pointer to |reference to )incomplete type (.*?) is not allowed in exception specification",

[f]=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-exception\\-spec[^\\]]*\\]",

[e]=n,

[d]={"b2b0da4ad08d",1465583081,"[-fms-extensions] Permit incomplete types in dynamic exception specifications","[-fms-extensions] Permit incomplete types in dynamic exception specifications\n\nMicrosoft headers, comdef.h and comutil.h, assume that this is an OK\nthing to do.  Downgrade the hard error to a warning if we are in\n-fms-extensions mode.\n\nThis fixes PR28080.\n\nllvm-svn: 272412"},

[c]={{Hb,168,"/// CheckSpecifiedExceptionType - Check if the given type is valid in an\n/// exception specification. Incomplete types, or pointers to incomplete types\n/// other than void are not allowed.\n///\n/// \\param[in,out] T  The exception type. This will be decayed to a pointer type\n///                  when the input is an array or a function type.\nbool Sema::CheckSpecifiedExceptionType(QualType &T, SourceRange Range) {\n  // ...\n  if (getLangOpts().MSVCCompat) {\n    DiagID = diag::ext_incomplete_in_exception_spec;"}},

[m]={"increment-bool"},

[l]="increment-bool",

[h]="ext_increment_bool",

[i]="ISO C++1z does not allow incrementing expression of type bool",

[a]=P,

[g]="ISO C\\+\\+17 does not allow incrementing expression of type bool",

[f]=" \\[[^\\]]*\\-Wincrement\\-bool[^\\]]*\\]",

[e]=n,

[d]={"4a0cd893257d",1448504197,"P0002R1: increment on expressions of type bool is no longer allowed in C++1z.","P0002R1: increment on expressions of type bool is no longer allowed in C++1z.\n\nllvm-svn: 254122"},

[c]={{u,14703,"/// CheckIncrementDecrementOperand - unlike most \"Check\" methods, this routine\n/// doesn\'t need to call UsualUnaryConversions or UsualArithmeticConversions.\nstatic QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation OpLoc, bool IsInc, bool IsPrefix) {\n  // ...\n  if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) {\n    // ...\n    S.Diag(OpLoc, S.getLangOpts().CPlusPlus17 ? diag::ext_increment_bool : diag::warn_increment_bool) << Op->getSourceRange();"}},

[m]={"c++14-extensions","c++1y-extensions"},

[l]="c++14-extensions",

[h]="ext_init_capture",

[i]="initialized lambda captures are a C++14 extension",

[a]=o,

[g]="initialized lambda captures are a C\\+\\+14 extension",

[f]=" \\[(?:\\-Werror,)?\\-Wc\\+\\+14\\-extensions[^\\]]*\\]",

[e]="Lambda Issue",

[d]={"5b013f505068",1380346707,"Add compat/extension warnings for init captures.","Add compat/extension warnings for init captures.\n\nllvm-svn: 191609"},

[c]={{"clang/lib/Sema/SemaLambda.cpp",1072,"void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, Scope *CurrentScope) {\n  // ...\n  for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; PrevCaptureLoc = C->Loc, ++C) {\n    // ...\n    if (C->Init.isUsable()) {\n      Diag(C->Loc, getLangOpts().CPlusPlus14 ? diag::warn_cxx11_compat_init_capture : diag::ext_init_capture);"}},

[m]={ib,gc},

[l]=ib,

[h]={{nil,r,"ext_init_capture_pack"}},

[i]={{nil,p,"initialized lambda pack captures are a C++20 extension"},{r,r,"initialized lambda pack captures are a C++2a extension"}},

[a]=o,

[g]="initialized lambda pack captures are a C\\+\\+20 extension",

[f]=bc,

[e]={{nil,r,"Lambda Issue"}},

[d]={"b2997f579a8b",1558469450,"[c++20] P0780R2: Support pack-expansion of init-captures.","[c++20] P0780R2: Support pack-expansion of init-captures.\n\nThis permits an init-capture to introduce a new pack:\n\n  template<typename ...T> auto x = [...a = T()] { /* a is a pack */ };\n\nTo support this, the mechanism for allowing ParmVarDecls to be packs has\nbeen extended to support arbitrary local VarDecls.\n\nllvm-svn: 361300"},

[c]={{"clang/lib/Sema/SemaLambda.cpp",729,"QualType Sema::buildLambdaInitCaptureInitialization(SourceLocation Loc, bool ByRef, SourceLocation EllipsisLoc, std::optional<unsigned> NumExpansions, IdentifierInfo *Id, bool IsDirectInit, Expr *&Init) {\n  // ...\n  if (EllipsisLoc.isValid()) {\n    if (Init->containsUnexpandedParameterPack()) {\n      Diag(EllipsisLoc, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_init_capture_pack : diag::ext_init_capture_pack);"}},

[m]={E,"microsoft-init-from-predefined"},

[l]="microsoft-init-from-predefined",

[h]="ext_init_from_predefined",

[i]="initializing an array from a \'A\' predefined identifier is a Microsoft extension",

[a]=o,

[g]="initializing an array from a \'(.*?)\' predefined identifier is a Microsoft extension",

[f]=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-init\\-from\\-predefined[^\\]]*\\]",

[e]=n,

[d]={kc,1625925174,dc,fc},

[c]={{nb,8619,"ExprResult InitializationSequence::Perform(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, MultiExprArg Args, QualType *ResultType) {\n  // ...\n  if (S.getLangOpts().MicrosoftExt && Args.size() == 1 && isa<PredefinedExpr>(Args[0]) && Entity.getType()->isArrayType()) {\n    // ...\n    S.Diag(Init->getBeginLoc(), diag::ext_init_from_predefined) << Init;"}},

[m]={Xc,"c++0x-narrowing",Fc,Ec,Cc,"narrowing"},

[l]=Cc,

[h]="ext_init_list_constant_narrowing",

[i]="constant expression evaluates to A which cannot be narrowed to type B",

[a]=P,

[g]="constant expression evaluates to (.*?) which cannot be narrowed to type (.*?)",

[f]=" \\[[^\\]]*\\-Wc\\+\\+11\\-narrowing[^\\]]*\\]",

[e]=n,

[d]={"16e1b07597f3",1384224105,"Rather than duplicating extension diagnostics to allow them to cause a","Rather than duplicating extension diagnostics to allow them to cause a\nsubstitution failure, allow a flag to be set on the Diagnostic object,\nto mark it as \'causes substitution failure\'.\n\nRefactor Diagnostic.td and the tablegen to use an enum for SFINAE behavior\nrather than a bunch of flags.\n\nllvm-svn: 194444"},

[c]={{nb,10426,"static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit) {\n  // ...\n  case NK_Constant_Narrowing:\n    // ...\n    S.Diag(PostInit->getBeginLoc(), NarrowingErrs(S.getLangOpts()) ? diag::ext_init_list_constant_narrowing : diag::warn_init_list_constant_narrowing) << PostInit->getSourceRange() << ConstantValue.getAsString(S.getASTContext(), ConstantType) << EntityType.getLocalUnqualifiedType();"}},

[m]={Xc,"c++0x-narrowing",Fc,Ec,Cc,"narrowing"},

[l]=Cc,

[h]="ext_init_list_type_narrowing",

[i]="type A cannot be narrowed to B in initializer list",

[a]=P,

[g]="type (.*?) cannot be narrowed to (.*?) in initializer list",

[f]=" \\[[^\\]]*\\-Wc\\+\\+11\\-narrowing[^\\]]*\\]",

[e]=n,

[d]={"16e1b07597f3",1384224105,"Rather than duplicating extension diagnostics to allow them to cause a","Rather than duplicating extension diagnostics to allow them to cause a\nsubstitution failure, allow a flag to be set on the Diagnostic object,\nto mark it as \'causes substitution failure\'.\n\nRefactor Diagnostic.td and the tablegen to use an enum for SFINAE behavior\nrather than a bunch of flags.\n\nllvm-svn: 194444"},

[c]={{nb,10415,"static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit) {\n  // ...\n  case NK_Type_Narrowing:\n    // ...\n    S.Diag(PostInit->getBeginLoc(), NarrowingErrs(S.getLangOpts()) ? diag::ext_init_list_type_narrowing : diag::warn_init_list_type_narrowing) << PostInit->getSourceRange() << PreNarrowingType.getLocalUnqualifiedType() << EntityType.getLocalUnqualifiedType();"}},

[m]={Xc,"c++0x-narrowing",Fc,Ec,Cc,"narrowing"},

[l]=Cc,

[h]="ext_init_list_variable_narrowing",

[i]="non-constant-expression cannot be narrowed from type A to B in initializer list",

[a]=P,

[g]="non\\-constant\\-expression cannot be narrowed from type (.*?) to (.*?) in initializer list",

[f]=" \\[[^\\]]*\\-Wc\\+\\+11\\-narrowing[^\\]]*\\]",

[e]=n,

[d]={"16e1b07597f3",1384224105,"Rather than duplicating extension diagnostics to allow them to cause a","Rather than duplicating extension diagnostics to allow them to cause a\nsubstitution failure, allow a flag to be set on the Diagnostic object,\nto mark it as \'causes substitution failure\'.\n\nRefactor Diagnostic.td and the tablegen to use an enum for SFINAE behavior\nrather than a bunch of flags.\n\nllvm-svn: 194444"},

[c]={{nb,10437,"static void DiagnoseNarrowingInInitList(Sema &S, const ImplicitConversionSequence &ICS, QualType PreNarrowingType, QualType EntityType, const Expr *PostInit) {\n  // ...\n  case NK_Variable_Narrowing:\n    // ...\n    S.Diag(PostInit->getBeginLoc(), NarrowingErrs(S.getLangOpts()) ? diag::ext_init_list_variable_narrowing : diag::warn_init_list_variable_narrowing) << PostInit->getSourceRange() << PreNarrowingType.getLocalUnqualifiedType() << EntityType.getLocalUnqualifiedType();"}},

[m]={Y,Bb},

[l]=Y,

[h]="ext_init_statement",

[i]={{nil,Z,{"\'",{"if","switch"},"\' initialization statements are a C++17 extension"}},{nil,nil,{"\'",{"if","switch"},"\' initialization statements are a C++1z extension"}}},

[a]=o,

[g]="\'(?:if|switch)\' initialization statements are a C\\+\\+17 extension",

[f]=zb,

[e]=F,

[d]={"fccb5128b201",1476822436,"Add missing warning for use of C++1z init-statements in C++14 and before.","Add missing warning for use of C++1z init-statements in C++14 and before.\n\nllvm-svn: 284530"},

[c]={{"clang/lib/Parse/ParseExprCXX.cpp",2075,"/// ParseCXXCondition - if/switch/while condition expression.\n///\n///      condition:\n///        expression\n///        type-specifier-seq declarator \'=\' assignment-expression\n/// [C++11] type-specifier-seq declarator \'=\' initializer-clause\n/// [C++11] type-specifier-seq declarator braced-init-list\n/// [Clang] type-specifier-seq ref-qualifier[opt] \'[\' identifier-list \']\'\n///            brace-or-equal-initializer\n/// [GNU]  type-specifier-seq declarator simple-asm-expr[opt] attributes[opt]\n///            \'=\' assignment-expression\n///\n/// In C++1z, a condition may in some contexts be preceded by an\n/// optional init-statement. This function will parse that too.\n///\n/// \\param InitStmt If non-null, an init-statement is permitted, and if present\n/// will be parsed and stored here.\n///\n/// \\param Loc The location of the start of the statement that requires this\n/// condition, e.g., the \"for\" in a for loop.\n///\n/// \\param MissingOK Whether an empty condition is acceptable here. Otherwise\n/// it is considered an error to be recovered from.\n///\n/// \\param FRI If non-null, a for range declaration is permitted, and if\n/// present will be parsed and stored here, and a null result will be returned.\n///\n/// \\param EnterForConditionScope If true, enter a continue/break scope at the\n/// appropriate moment for a \'for\' loop.\n///\n/// \\returns The parsed condition.\nSema::ConditionResult Parser::ParseCXXCondition(StmtResult *InitStmt, SourceLocation Loc, Sema::ConditionKind CK, bool MissingOK, ForRangeInfo *FRI, bool EnterForConditionScope) {\n  // ...\n  const auto WarnOnInit = [this, &CK] { Diag(Tok.getLocation(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_init_statement : diag::ext_init_statement) << (CK == Sema::ConditionKind::Switch); };"}},

[m]={k,kb,"extra","initializer-overrides","override-init"},

[l]="initializer-overrides",

[h]="ext_initializer_overrides",

[i]={{nil,p,{"initializer ",{"partially ",k},"overrides prior initialization of this subobject"}}},

[a]=o,

[g]="initializer (?:partially |)overrides prior initialization of this subobject",

[f]=" \\[(?:\\-Werror,)?\\-Winitializer\\-overrides[^\\]]*\\]",

[e]={{nil,p,n}},

[d]={"5030928d60a1",1567205575,"[c++20] Implement semantic restrictions for C++20 designated","[c++20] Implement semantic restrictions for C++20 designated\ninitializers.\n\nThis has some interesting interactions with our existing extensions to\nsupport C99 designated initializers as an extension in C++. Those are\nresolved as follows:\n\n * We continue to permit the full breadth of C99 designated initializers\n  in C++, with the exception that we disallow a partial overwrite of an\n  initializer with a non-trivially-destructible type. (Full overwrite\n  is OK, because we won\'t run the first initializer at all.)\n\n * The C99 extensions are disallowed in SFINAE contexts and during\n  overload resolution, where they could change the meaning of valid\n  programs.\n\n * C++20 disallows reordering of initializers. We only check for that for\n  the simple cases that the C++20 rules permit (designators of the form\n  \'.field_name =\' and continue to allow reordering in other cases).\n  It would be nice to improve this behavior in future.\n\n * All C99 designated initializer extensions produce a warning by\n  default in C++20 mode. People are going to learn the C++ rules based\n  on what Clang diagnoses, so it\'s important we diagnose these properly\n  by default.\n\n * In C++ <= 17, we apply the C++20 rules rather than the C99 rules, and\n  so still diagnose C99 extensions as described above. We continue to\n  accept designated C++20-compatible initializers in C++ <= 17 silently\n  by default (but naturally still reject under -pedantic-errors).\n\nThis is not a complete implementation of P0329R4. In particular, that\npaper introduces new non-C99-compatible syntax { .field { init } }, and\nwe do not support that yet.\n\nThis is based on a previous patch by Don Hinton, though I\'ve made\nsubstantial changes when addressing the above interactions.\n\nDifferential Revision: https://reviews.llvm.org/D59754\n\nllvm-svn: 370544"},

[c]={{nb,415,"/// Semantic checking for initializer lists.\n///\n/// The InitListChecker class contains a set of routines that each\n/// handle the initialization of a certain kind of entity, e.g.,\n/// arrays, vectors, struct/union types, scalars, etc. The\n/// InitListChecker itself performs a recursive walk of the subobject\n/// structure of the type to be initialized, while stepping through\n/// the initializer list one element at a time. The IList and Index\n/// parameters to each of the Check* routines contain the active\n/// (syntactic) initializer list and the index into that initializer\n/// list that represents the current initializer. Each routine is\n/// responsible for moving that Index forward as it consumes elements.\n///\n/// Each Check* routine also has a StructuredList/StructuredIndex\n/// arguments, which contains the current \"structured\" (semantic)\n/// initializer list and the index into that initializer list where we\n/// are copying initializers as we map them over to the semantic\n/// list. Once we have completed our recursive walk of the subobject\n/// structure, we will have constructed a full semantic initializer\n/// list.\n///\n/// C99 designators cause changes in the initializer list traversal,\n/// because they make the initialization \"jump\" into a specific\n/// subobject and then continue the initialization from that\n/// point. CheckDesignatedInitializer() recursively steps into the\n/// designated subobject and manages backing out the recursion to\n/// initialize the subobjects after the one designated.\n///\n/// If an initializer list contains any designators, we build a placeholder\n/// structured list even in \'verify only\' mode, so that we can track which\n/// elements need \'empty\' initializtion.\nclass InitListChecker {\n  // ...\n  /// Diagnose that OldInit (or part thereof) has been overridden by NewInit.\n  void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange, bool UnionOverride = false, bool FullyOverwritten = true) {\n    // ...\n    unsigned DiagID = SemaRef.getLangOpts().CPlusPlus ? (UnionOverride ? diag::ext_initializer_union_overrides : diag::ext_initializer_overrides) : diag::warn_initializer_overrides;"}}

[m]={"excess-initializers"},

[l]="excess-initializers",

[h]="ext_initializer_string_for_char_array_too_long",

[i]="initializer-string for char array is too long",

[a]=o,

[g]="initializer\\-string for char array is too long",

[f]=" \\[(?:\\-Werror,)?\\-Wexcess\\-initializers[^\\]]*\\]",

[e]=n,

[d]={tb,1405733957,ub,sb},

[c]={{nb,258,"static void CheckStringInit(Expr *Str, QualType &DeclT, const ArrayType *AT, Sema &S) {\n  // ...\n  // We have an array of character type with known size.  However,\n  // the size may be smaller or larger than the string we are initializing.\n  // FIXME: Avoid truncation for 64-bit length strings.\n  if (S.getLangOpts().CPlusPlus) {\n  // ...\n  } else {\n    // C99 6.7.8p14.\n    if (StrLength - 1 > CAT->getSize().getZExtValue())\n      S.Diag(Str->getBeginLoc(), diag::ext_initializer_string_for_char_array_too_long) << Str->getSourceRange();"}},

[m]={k,kb,"extra","initializer-overrides","override-init"},

[l]="initializer-overrides",

[h]="ext_initializer_union_overrides",

[i]={{nil,nil,{"initializer ",{"partially ",k},"overrides prior initialization of this subobject"}}},

[a]=P,

[g]="initializer (?:partially |)overrides prior initialization of this subobject",

[f]=" \\[[^\\]]*\\-Winitializer\\-overrides[^\\]]*\\]",

[e]=n,

[d]={kc,1625925174,dc,fc},

[c]={{nb,414,"/// Semantic checking for initializer lists.\n///\n/// The InitListChecker class contains a set of routines that each\n/// handle the initialization of a certain kind of entity, e.g.,\n/// arrays, vectors, struct/union types, scalars, etc. The\n/// InitListChecker itself performs a recursive walk of the subobject\n/// structure of the type to be initialized, while stepping through\n/// the initializer list one element at a time. The IList and Index\n/// parameters to each of the Check* routines contain the active\n/// (syntactic) initializer list and the index into that initializer\n/// list that represents the current initializer. Each routine is\n/// responsible for moving that Index forward as it consumes elements.\n///\n/// Each Check* routine also has a StructuredList/StructuredIndex\n/// arguments, which contains the current \"structured\" (semantic)\n/// initializer list and the index into that initializer list where we\n/// are copying initializers as we map them over to the semantic\n/// list. Once we have completed our recursive walk of the subobject\n/// structure, we will have constructed a full semantic initializer\n/// list.\n///\n/// C99 designators cause changes in the initializer list traversal,\n/// because they make the initialization \"jump\" into a specific\n/// subobject and then continue the initialization from that\n/// point. CheckDesignatedInitializer() recursively steps into the\n/// designated subobject and manages backing out the recursion to\n/// initialize the subobjects after the one designated.\n///\n/// If an initializer list contains any designators, we build a placeholder\n/// structured list even in \'verify only\' mode, so that we can track which\n/// elements need \'empty\' initializtion.\nclass InitListChecker {\n  // ...\n  /// Diagnose that OldInit (or part thereof) has been overridden by NewInit.\n  void diagnoseInitOverride(Expr *OldInit, SourceRange NewInitRange, bool UnionOverride = false, bool FullyOverwritten = true) {\n    // ...\n    unsigned DiagID = SemaRef.getLangOpts().CPlusPlus ? (UnionOverride ? diag::ext_initializer_union_overrides : diag::ext_initializer_overrides) : diag::warn_initializer_overrides;"}},

[m]={gb,H,"c++11-inline-namespace"},

[l]="c++11-inline-namespace",

[h]="ext_inline_namespace",

[i]="inline namespaces are a C++11 feature",

[a]=o,

[g]="inline namespaces are a C\\+\\+11 feature",

[f]=" \\[(?:\\-Werror,)?\\-Wc\\+\\+11\\-inline\\-namespace[^\\]]*\\]",

[e]=F,

[d]={"5a5f2c76b6f7",1283215005,"Enable inline namespaces in C++03 as an extension.","Enable inline namespaces in C++03 as an extension.\n\nllvm-svn: 112566"},

[c]={{Q,225,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  // ...\n  // If we\'re still good, complain about inline namespaces in non-C++0x now.\n  if (InlineLoc.isValid())\n    Diag(InlineLoc, getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_inline_namespace : diag::ext_inline_namespace);"}},

[m]={ib,gc},

[l]=ib,

[h]={{nil,C,"ext_inline_nested_namespace_definition"}},

[b]={{nil,p,"inline nested namespace definition is a C++20 extension"},{r,C,"inline nested namespace definition is a C++2a extension"}},

[i]={{nil,p,"inline nested namespace definition is a C++20 extension"},{r,C,"inline nested namespace definition is a C++2a extension"}},

[a]=o,

[g]="inline nested namespace definition is a C\\+\\+20 extension",

[f]=bc,

[e]={{nil,C,F}},

[d]={"53f391dcb323",1542043188,"Implement P1094R2 (nested inline namespaces)","Implement P1094R2 (nested inline namespaces)\n\nAs approved for the Working Paper in San Diego, support annotating\ninline namespaces with \'inline\'.\n\nChange-Id: I51a654e11ffb475bf27cccb2458768151619e384\nllvm-svn: 346677"},

[c]={{Q,183,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  // ...\n  if (ExtraNSs.empty()) {\n  // ...\n  } else if (InlineLoc.isValid()) {\n  // ...\n  } else if (getLangOpts().CPlusPlus20) {\n  // ...\n  } else if (getLangOpts().CPlusPlus17) {\n    // ...\n    if (FirstNestedInlineLoc.isValid())\n      Diag(FirstNestedInlineLoc, diag::ext_inline_nested_namespace_definition);"},{Q,218,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  // ...\n  if (ExtraNSs.empty()) {\n  // ...\n  } else if (InlineLoc.isValid()) {\n  // ...\n  } else if (getLangOpts().CPlusPlus20) {\n  // ...\n  } else if (getLangOpts().CPlusPlus17) {\n  // ...\n  } else {\n    // ...\n    // Warn about nested inline namespaces.\n    if (FirstNestedInlineLoc.isValid())\n      Diag(FirstNestedInlineLoc, diag::ext_inline_nested_namespace_definition);"}},

[m]={Y,Bb},

[l]=Y,

[h]="ext_inline_variable",

[i]="inline variables are a C++1z extension",

[a]=o,

[g]="inline variables are a C\\+\\+17 extension",

[f]=zb,

[e]=n,

[d]={"62f19e700d31",1466813756,"Implement C++17 P0386R2, inline variables. (The \'inline\' specifier gives a","Implement C++17 P0386R2, inline variables. (The \'inline\' specifier gives a\nvariable weak discardable linkage and partially-ordered initialization, and is\nimplied for constexpr static data members.)\n\nllvm-svn: 273754"},

[c]={{v,7732,"NamedDecl *Sema::ActOnVariableDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamLists, bool &AddToScope, ArrayRef<BindingDecl *> Bindings) {\n  // ...\n  if (D.getDeclSpec().isInlineSpecified()) {\n    if (!getLangOpts().CPlusPlus) {\n    // ...\n    } else if (CurContext->isFunctionOrMethod()) {\n    // ...\n    } else {\n      Diag(D.getDeclSpec().getInlineSpecLoc(), getLangOpts().CPlusPlus17 ? diag::warn_cxx14_compat_inline_variable : diag::ext_inline_variable);"}},

[m]={t},

[l]=t,

[h]="ext_integer_complement_complex",

[i]="ISO C does not support \'~\' for complex conjugation of A",

[a]=o,

[g]="ISO C does not support \'~\' for complex conjugation of (.*?)",

[f]=X,

[e]=n,

[d]={T,1237025389,S,R},

[c]={{u,16246,"ExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, Expr *InputExpr, bool IsAfterAmp) {\n  // ...\n  case UO_Not: // bitwise complement\n    // ...\n    // C99 6.5.3.3p1. We allow complex int and float as a GCC extension.\n    if (resultType->isComplexType() || resultType->isComplexIntegerType())\n      // ...\n      Diag(OpLoc, diag::ext_integer_complement_complex) << resultType << Input.get()->getSourceRange();"}}

[m]={V,"gnu-complex-integer",t},

[l]="gnu-complex-integer",

[h]="ext_integer_complex",

[f]=" \\[(?:\\-Werror,)?\\-Wgnu\\-complex\\-integer[^\\]]*\\]",

[e]=n,

[d]={K,1236199783,L,M},

[c]={{Tc,1316,"/// 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  // TODO: if the implementation does not implement _Complex or _Imaginary,\n  // disallow their use.  Need information about the backend.\n  if (TypeSpecComplex != TSC_unspecified) {\n    if (TypeSpecType == TST_unspecified) {\n    // ...\n    } else if (TypeSpecType == TST_int || TypeSpecType == TST_char || TypeSpecType == TST_bitint) {\n      // Note that this intentionally doesn\'t include _Complex _Bool.\n      if (!S.getLangOpts().CPlusPlus)\n        S.Diag(TSTLoc, diag::ext_integer_complex);"}},

[m]={t},

[l]=t,

[h]="ext_integer_increment_complex",

[i]="ISO C does not support \'++\'/\'--\' on complex integer type A",

[a]=o,

[g]="ISO C does not support \'\\+\\+\'\\/\'\\-\\-\' on complex integer type (.*?)",

[f]=X,

[e]=n,

[d]={T,1237025389,S,R},

[c]={{u,14740,"/// CheckIncrementDecrementOperand - unlike most \"Check\" methods, this routine\n/// doesn\'t need to call UsualUnaryConversions or UsualArithmeticConversions.\nstatic QualType CheckIncrementDecrementOperand(Sema &S, Expr *Op, ExprValueKind &VK, ExprObjectKind &OK, SourceLocation OpLoc, bool IsInc, bool IsPrefix) {\n  // ...\n  if (S.getLangOpts().CPlusPlus && ResType->isBooleanType()) {\n  // ...\n  } else if (S.getLangOpts().CPlusPlus && ResType->isEnumeralType()) {\n  // ...\n  } else if (ResType->isRealType()) {\n  // ...\n  } else if (ResType->isPointerType()) {\n  // ...\n  } else if (ResType->isObjCObjectPointerType()) {\n  // ...\n  } else if (ResType->isAnyComplexType()) {\n    // ...\n    S.Diag(OpLoc, diag::ext_integer_increment_complex) << ResType << Op->getSourceRange();"}}

[m]={"implicitly-unsigned-literal"},

[l]="implicitly-unsigned-literal",

[h]="ext_integer_literal_too_large_for_signed",

[f]=" \\[(?:\\-Werror,)?\\-Wimplicitly\\-unsigned\\-literal[^\\]]*\\]",

[e]=k,

[d]={"31f42318d833",1406213483,"Improving the \"integer constant too large\" diagnostics based on post-commit feedback from Richard Sm...","Improving the \"integer constant too large\" diagnostics based on post-commit feedback from Richard Smith. Amends r213657.\n\nllvm-svn: 213865"},

[c]={{"clang/lib/Lex/PPExpressions.cpp",363,"/// 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    // Parse the integer literal into Result.\n    if (Literal.GetIntegerValue(Result.Val)) {\n    // ...\n    } else {\n      // ...\n      // Detect overflow based on whether the value is signed.  If signed\n      // and if the value is too large, emit a warning \"integer constant is so\n      // large that it is unsigned\" e.g. on 12345678901234567890 where intmax_t\n      // is 64-bits.\n      if (!Literal.isUnsigned && Result.Val.isNegative()) {\n        // Octal, hexadecimal, and binary literals are implicitly unsigned if\n        // the value does not fit into a signed integer type.\n        if (ValueLive && Literal.getRadix() == 10)\n          PP.Diag(PeekTok, diag::ext_integer_literal_too_large_for_signed);"},{u,4257,"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    if (Literal.GetIntegerValue(ResultVal)) {\n    // ...\n    } else {\n      // ...\n      // If we still couldn\'t decide a type, we either have \'size_t\' literal\n      // that is out of range, or a decimal literal that does not fit in a\n      // signed long long and has no U suffix.\n      if (Ty.isNull()) {\n        if (Literal.isSizeT)\n        // ...\n        else\n          Diag(Tok.getLocation(), diag::ext_integer_literal_too_large_for_signed);"}},

[m]={"static-in-inline"},

[l]="static-in-inline",

[h]="ext_internal_in_extern_inline",

[i]={{nil,nil,{"static ",{Zb,ac}," B is used in an inline function with external linkage"}}},

[a]=o,

[g]="static (?:function|variable) (.*?) is used in an inline function with external linkage",

[f]=" \\[(?:\\-Werror,)?\\-Wstatic\\-in\\-inline[^\\]]*\\]",

[e]=n,

[d]={"edff0200115c",1340041798,"Allow internal decls in inline functions if the function is in the main file.","Allow internal decls in inline functions if the function is in the main file.\n\nThis handles the very common case of people writing inline functions in their\nmain source files and not tagging them as inline. These cases should still\nbehave as the user intended. (The diagnostic is still emitted as an extension.)\n\nI\'m reworking this code anyway to account for C++\'s equivalent restriction in\n[basic.def.odr]p6, but this should get some bots back to green.\n\nllvm-svn: 158666"},

[c]={{u,192,"/// Check whether we\'re in an extern inline function and referring to a\n/// variable or function with internal linkage (C11 6.7.4p3).\n///\n/// This is only a warning because we used to silently accept this code, but\n/// in many cases it will not behave correctly. This is not enabled in C++ mode\n/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)\n/// and so while there may still be user mistakes, most of the time we can\'t\n/// prove that there are errors.\nstatic void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, const NamedDecl *D, SourceLocation Loc) {\n  // ...\n  S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet : diag::ext_internal_in_extern_inline) << /*IsVar=*/!UsedFn << D;"}},

[m]={t,"static-in-inline"},

[l]="static-in-inline",

[h]="ext_internal_in_extern_inline_quiet",

[i]={{nil,nil,{"static ",{Zb,ac}," B is used in an inline function with external linkage"}}},

[a]=o,

[g]="static (?:function|variable) (.*?) is used in an inline function with external linkage",

[f]=" \\[(?:\\-Werror,)?\\-Wstatic\\-in\\-inline[^\\]]*\\]",

[e]=n,

[d]={tb,1405733957,ub,sb},

[c]={{u,191,"/// Check whether we\'re in an extern inline function and referring to a\n/// variable or function with internal linkage (C11 6.7.4p3).\n///\n/// This is only a warning because we used to silently accept this code, but\n/// in many cases it will not behave correctly. This is not enabled in C++ mode\n/// because the restriction language is a bit weaker (C++11 [basic.def.odr]p6)\n/// and so while there may still be user mistakes, most of the time we can\'t\n/// prove that there are errors.\nstatic void diagnoseUseOfInternalDeclInInlineFunction(Sema &S, const NamedDecl *D, SourceLocation Loc) {\n  // ...\n  S.Diag(Loc, DowngradeWarning ? diag::ext_internal_in_extern_inline_quiet : diag::ext_internal_in_extern_inline) << /*IsVar=*/!UsedFn << D;"}}

[m]={"keyword-compat"},

[l]="keyword-compat",

[h]="ext_keyword_as_ident",

[i]={{nil,nil,{"keyword \'A\' will be made available as an identifier ",{"here","for the remainder of the translation unit"}}}},

[a]=o,

[g]="keyword \'(.*?)\' will be made available as an identifier (?:here|for the remainder of the translation unit)",

[f]=" \\[(?:\\-Werror,)?\\-Wkeyword\\-compat[^\\]]*\\]",

[e]=F,

[d]={"47642d2b7ea1",1386051181,"Emit an extension warning when changing system header tokens","Emit an extension warning when changing system header tokens\n\nclang converts keywords to identifiers for compatibility with various system\nheaders such as GNU libc.\n\nImplement a -Wkeyword-compat extension warning to diagnose those cases. The\nwarning is on by default but will generally be ignored in system headers. It\ncan however be enabled globally to aid standards conformance testing.\n\nThis also changes the __uptr keyword avoidance from r195710 to no longer\nspecial-case system headers, bringing it in line with other similar workarounds\nin clang.\n\nImplementation returns bool for symmetry with token annotation functions.\n\nSome examples:\n\nwarning: keyword \'__is_pod\' will be treated as an identifier for the remainder of the translation unit [-Wkeyword-compat]\nstruct __is_pod\n\nwarning: keyword \'__uptr\' will be treated as an identifier here [-Wkeyword-compat]\nunion w *__uptr;\n\nllvm-svn: 196212"},

[c]={{"clang/lib/Parse/ParseExpr.cpp",1770,"#include \"clang/Basic/TransformTypeTraits.def\"\n    // HACK: libstdc++ uses some of the transform-type-traits as alias\n    // templates, so we need to work around this.\n    if (!NextToken().is(tok::l_paren)) {\n      // ...\n      Diag(Tok, diag::ext_keyword_as_ident) << Tok.getIdentifierInfo()->getName() << 0;"},{"clang/lib/Parse/ParseExprCXX.cpp",3134,"#include \"clang/Basic/TransformTypeTraits.def\"\n    if (!NextToken().is(tok::l_paren)) {\n      // ...\n      Diag(Tok, diag::ext_keyword_as_ident) << Tok.getIdentifierInfo()->getName() << 0;"},{"clang/lib/Parse/Parser.cpp",1915,"bool Parser::TryKeywordIdentFallback(bool DisableKeyword) {\n  // ...\n  Diag(Tok, diag::ext_keyword_as_ident) << PP.getSpelling(Tok) << DisableKeyword;"},{"clang/lib/Parse/ParseStmt.cpp",274,"#include \"clang/Basic/TransformTypeTraits.def\"\n      if (NextToken().is(tok::less)) {\n        // ...\n        Diag(Tok, diag::ext_keyword_as_ident) << Tok.getIdentifierInfo()->getName() << 0;"}},

[m]={"c++23-extensions","c++2b-extensions"},

[l]="c++23-extensions",

[h]={{nil,w,"ext_lambda_missing_parens"}},

[i]="lambda without a parameter clause is a C++23 extension",

[a]=o,

[g]="lambda without a parameter clause is a C\\+\\+23 extension",

[f]=" \\[(?:\\-Werror,)?\\-Wc\\+\\+23\\-extensions[^\\]]*\\]",

[e]={{nil,w,F}},

[d]={Pc,1612659633,Qc,Rc},

[c]={{"clang/lib/Parse/ParseExprCXX.cpp",1511,"/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda\n/// expression.\nExprResult Parser::ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro) {\n  // ...\n  if (HasSpecifiers && !HasParentheses && !getLangOpts().CPlusPlus23) {\n    // ...\n    Diag(Tok, diag::ext_lambda_missing_parens) << FixItHint::CreateInsertion(Tok.getLocation(), \"() \");"}},

[m]={ib,gc},

[l]=ib,

[h]={{nil,r,"ext_lambda_template_parameter_list"}},

[i]={{nil,p,"explicit template parameter list for lambdas is a C++20 extension"},{r,r,"explicit template parameter list for lambdas is a C++2a extension"}},

[a]=o,

[g]="explicit template parameter list for lambdas is a C\\+\\+20 extension",

[f]=bc,

[e]={{nil,r,F}},

[d]={"8205a814a691",1556966986,"[c++20] Implement P0428R2 - Familiar template syntax for generic lambdas","[c++20] Implement P0428R2 - Familiar template syntax for generic lambdas\n\nDifferential Revision: https://reviews.llvm.org/D36527\n\nllvm-svn: 359967"},

[c]={{"clang/lib/Parse/ParseExprCXX.cpp",1331,"/// ParseLambdaExpressionAfterIntroducer - Parse the rest of a lambda\n/// expression.\nExprResult Parser::ParseLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro) {\n  // ...\n  if (Tok.is(tok::less)) {\n    Diag(Tok, getLangOpts().CPlusPlus20 ? diag::warn_cxx17_compat_lambda_template_parameter_list : diag::ext_lambda_template_parameter_list);"}},

[m]={kb,qb,"comment","comments",pb,t},

[l]="comment",

[h]="ext_line_comment",

[i]="// comments are not allowed in this language",

[a]=o,

[g]="\\/\\/ comments are not allowed in this language",

[f]=" \\[(?:\\-Werror,)?\\-Wcomment[^\\]]*\\]",

[e]=A,

[d]={"158a31abe2c2",1352617334,"s/BCPLComment/LineComment/","s/BCPLComment/LineComment/\n\nllvm-svn: 167690"},

[c]={{Sb,2444,"/// We have just read the // characters from input.  Skip until we find the\n/// newline character that terminates the comment.  Then update BufferPtr and\n/// return.\n///\n/// If we\'re in KeepCommentMode or any CommentHandler has inserted\n/// some tokens, this will store the first token and return true.\nbool Lexer::SkipLineComment(Token &Result, const char *CurPtr, bool &TokAtPhysicalStartOfLine) {\n  // If Line comments aren\'t explicitly enabled for this language, emit an\n  // extension warning.\n  if (!LineComment) {\n    if (!isLexingRawMode()) // There\'s no PP in raw mode, so can\'t emit diags.\n      Diag(BufferPtr, diag::ext_line_comment);"}},

[m]={"main-return-type"},

[l]="main-return-type",

[h]="ext_main_returns_nonint",

[f]=" \\[(?:\\-Werror,)?\\-Wmain\\-return\\-type[^\\]]*\\]",

[e]=n,

[d]={"5ed3caf2e364",1329249052,"Warn about non-int main() results in GNU C mode instead of erroring.","Warn about non-int main() results in GNU C mode instead of erroring.\n\nBased on a patch by Vasiliy Korchagin!\n\nllvm-svn: 150500"},

[c]={{v,12128,"void Sema::CheckMain(FunctionDecl *FD, const DeclSpec &DS) {\n  // ...\n  if (getLangOpts().GNUMode && !getLangOpts().CPlusPlus) {\n    // ...\n    // GCC in C mode accepts qualified \'int\'.\n    if (Context.hasSameUnqualifiedType(FT->getReturnType(), Context.IntTy))\n    // ...\n    else {\n      Diag(FD->getTypeSpecStartLoc(), diag::ext_main_returns_nonint);"}},

[m]={Bc,t},

[l]=Bc,

[h]="ext_main_used",

[i]="ISO C++ does not allow \'main\' to be used by a program",

[a]=o,

[g]="ISO C\\+\\+ does not allow \'main\' to be used by a program",

[f]=" \\[(?:\\-Werror,)?\\-Wmain[^\\]]*\\]",

[e]=n,

[d]={"b63b6ee9a00e",1390354999,"Enforce restrictions that \'main\' is not allowed to be deleted, or to be used by","Enforce restrictions that \'main\' is not allowed to be deleted, or to be used by\nthe program, in C++. (We allow the latter as an extension, since we\'ve always\npermitted it, and GCC does the same, and our supported C++ ABIs don\'t do\nanything special in main.)\n\nllvm-svn: 199782"},

[c]={{u,249,"/// Determine whether the use of this declaration is valid, and\n/// emit any corresponding diagnostics.\n///\n/// This routine diagnoses various problems with referencing\n/// declarations that can occur when using a declaration. For example,\n/// it might warn if a deprecated or unavailable declaration is being\n/// used, or produce an error (and return true) if a C++0x deleted\n/// function is being used.\n///\n/// \\returns true if there was an error (this declaration cannot be\n/// referenced), false otherwise.\n///\nbool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks, ObjCInterfaceDecl *ClassReceiver, bool SkipTrailingRequiresClause) {\n  // ...\n  if (getLangOpts().CPlusPlus && isa<FunctionDecl>(D)) {\n    // ...\n    // C++ [basic.start.main]p3:\n    //  The function \'main\' shall not be used within a program.\n    if (cast<FunctionDecl>(D)->isMain())\n      Diag(Loc, diag::ext_main_used);"}},

[m]={"many-braces-around-scalar-init"},

[l]="many-braces-around-scalar-init",

[h]={{nil,z,"ext_many_braces_around_init"}},

[b]={{nil,z,"too many braces around %select{scalar |}0initializer"}},

[i]={{nil,z,{"too many braces around ",{"scalar ",k},"initializer"}}},

[a]=o,

[g]="too many braces around (?:scalar |)initializer",

[f]=" \\[(?:\\-Werror,)?\\-Wmany\\-braces\\-around\\-scalar\\-init[^\\]]*\\]",

[e]={{nil,z,n}},

[d]={"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"},

[c]={{nb,1655,"void InitListChecker::CheckScalarType(const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  // ...\n  if (InitListExpr *SubIList = dyn_cast<InitListExpr>(expr)) {\n    // FIXME: This is invalid, and accepting it causes overload resolution\n    // to pick the wrong overload in some corner cases.\n    if (!VerifyOnly)\n      SemaRef.Diag(SubIList->getBeginLoc(), diag::ext_many_braces_around_init) << DeclType->isSizelessBuiltinType() << SubIList->getSourceRange();"}},

[m]={"mathematical-notation-identifier-extension"},

[l]="mathematical-notation-identifier-extension",