Module:ClangDiags/DiagsLongData4: Difference between revisions

local b="regex1";

local c="commit";

local d="category_hist";

local e="regex2";

local f="regex3";

local g="hierarchical_hist";

local h="message_hist";

local i="id_hist";

local o="5.0";

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

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

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

local u="5a8987ca5113";

local v="12.0";

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

local y="15.0";

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

local A="6.0";

local B="clang/lib/Parse/ParsePragma.cpp";

local C="14.0";

local D="9.0";

local E="8.0";

local F="13.0";

local G="Lexical or Preprocessor Issue";

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

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

local K="b1c4d5507fad";

local M="16.0";

local N="clang/lib/Lex/PPDirectives.cpp";

local O="7.0";

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

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

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

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

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

local U="931fcd3ba011";

local V="clang/lib/Sema/SemaExprMember.cpp";

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

local ab="95f50964fbf5";

local bb="Implement P2361 Unevaluated string literals";

local cb="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 db="clang/lib/Sema/SemaDeclAttr.cpp";

local eb="Add #pragma clang attribute\n\nThe new \'#pragma clang attribute\' directive can be used to apply attributes to\nmultiple declarations. An attribute must satisfy the following conditions to\nbe supported by the pragma:\n- It must have a subject list that\'s defined in the TableGen file.\n- It must be documented.\n- It must not be late parsed.\n- It must have a GNU/C++11 spelling.\n\nDifferential Revision: https://reviews.llvm.org/D30009\n\nllvm-svn: 300539";

local fb="Add #pragma clang attribute";

local gb="0a849f47d2f7";

local ib="11.1";

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

local kb="method";

local lb="14f6bfcb52e7";

local nb="[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 ob="clang/test/Parser/pragma-attribute.cpp";

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

local rb="block";

local sb="arguments to ";

local ub="execution configuration ";

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

local wb="f881267db9a9";

local xb="passing A to parameter of type B";

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

local zb="assigning to different types";

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

local Bb="converting A to type B";

local Cb="converting between types";

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

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

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

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

local Hb="casting A to type B";

local Ib="casting between types";

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

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

local Ob=" B";

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

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

local Rb="capturing value";

local Sb="initializing vector element";

local Tb="clang/test/Sema/fp-eval-pragma-with-float-double_t-1.c:28:15: error: cannot use type \'float_t\' within \'#pragma clang fp eval_method\'; type is set according to the default eval method for the translation unit";

local Ub="clang/test/Sema/fp-eval-pragma-with-float-double_t-1.c:30:16: error: cannot use type \'double_t\' within \'#pragma clang fp eval_method\'; type is set according to the default eval method for the translation unit";

local Vb="clang/lib/Parse/ParseExprCXX.cpp";

local Wb="assigning to A from B";

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

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

local kc="s";

local lc="invalid";

local mc="class";

local nc="Add a warning, flags and pragmas to limit the number of pre-processor tokens in a translation unit";

local oc="Add a warning, flags and pragmas to limit the number of pre-processor tokens in a translation unit\n\nSee\nhttps://docs.google.com/document/d/1xMkTZMKx9llnMPgso0jrx3ankI4cv60xeZ0y4ksf4wc/preview\nfor background discussion.\n\nThis adds a warning, flags and pragmas to limit the number of\npre-processor tokens either at a certain point in a translation unit, or\noverall.\n\nThe idea is that this would allow projects to limit the size of certain\nwidely included headers, or for translation units overall, as a way to\ninsert backstops for header bloat and prevent compile-time regressions.\n\nDifferential revision: https://reviews.llvm.org/D72703";

local pc="function template";

local qc="clang/lib/Sema/Sema.cpp";

local rc=" (A and B)";

local sc="<unused>";

local uc="\'";

local wc="Improve static checks for sprintf and __builtin___sprintf_chk";

local xc="Improve static checks for sprintf and __builtin___sprintf_chk\n\nImplement a pessimistic evaluator of the minimal required size for a buffer\nbased on the format string, and couple that with the fortified version to emit a\nwarning when the buffer size is lower than the lower bound computed from the\nformat string.\n\nDifferential Revision: https://reviews.llvm.org/D71566";

local yc="initializing statement expression result";

local Ac="clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1-11.cpp";

local Bc="missing";

local Cc="too few ";

local Dc=" of type B";

local Ec="clang/lib/Lex/PPMacroExpansion.cpp";

local Fc="variable template";

local Gc="struct";

local Hc="Refactoring Invocation Issue";

local Kc="; take the address with &";

local Mc="clang/test/Parser/cxx2a-concepts-requires-expr.cpp";

local Oc="clang/lib/Parse/ParseStmt.cpp";

local Pc="too many ";

local Qc="; remove *";

local Rc="typedef";

local Sc="; remove &";

local Tc="__host__";

local Uc="__global__";

local Vc="3dbcea8b957a";

local Wc="volatile";

local Xc="__device__";

local Yc="__host__ __device__";

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

local ad="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 bd="clang/lib/Basic/Targets.cpp";

local cd="clang/test/Preprocessor/line-directive.c";

local dd="clang/test/CXX/dcl.dcl/dcl.spec/dcl.typedef/p2-0x.cpp";

local ed="clang/test/SemaCXX/exceptions.cpp";

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

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

local hd="f9c3310d32c6";

local id="lvalue";

local jd="sizeof";

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

local ld="Reimplement reference initialization (C++ [dcl.init.ref]) using the\nnew notion of an \"initialization sequence\", which encapsulates the\ncomputation of the initialization sequence along with diagnostic\ninformation and the capability to turn the computed sequence into an\nexpression. At present, I\'ve only switched one CheckReferenceInit\ncallers over to this new mechanism; more will follow.\n\nAside from (hopefully) being much more true to the standard, the\ndiagnostics provided by this reference-initialization code are a bit\nbetter than before. Some examples:\n\np5-var.cpp:54:12: error: non-const lvalue reference to type \'struct\nDerived\'\n      cannot bind to a value of unrelated type \'struct Base\'\n  Derived &dr2 = b; // expected-error{{non-const lvalue reference to\n  ...\n          ^    ~\np5-var.cpp:55:9: error: binding of reference to type \'struct Base\' to\na value of\n      type \'struct Base const\' drops qualifiers\n  Base &br3 = bc; // expected-error{{drops qualifiers}}\n        ^    ~~\n\np5-var.cpp:57:15: error: ambiguous conversion from derived class\n      \'struct Diamond\' to base class \'struct Base\':\n    struct Diamond -> struct Derived -> struct Base\n    struct Diamond -> struct Derived2 -> struct Base\n  Base &br5 = diamond; // expected-error{{ambiguous conversion from\n     ...\n             ^~~~~~~\np5-var.cpp:59:9: error: non-const lvalue reference to type \'long\'\n      cannot bind to\n      a value of unrelated type \'int\'\n  long &lr = i; // expected-error{{non-const lvalue reference to type\n     ...\n        ^   ~\n\np5-var.cpp:74:9: error: non-const lvalue reference to type \'struct\nBase\' cannot\n      bind to a temporary of type \'struct Base\'\n  Base &br1 = Base(); // expected-error{{non-const lvalue reference to\n ...\n       ^     ~~~~~~\n\np5-var.cpp:102:9: error: non-const reference cannot bind to bit-field\n\'i\'\n int & ir1 = (ib.i); // expected-error{{non-const reference cannot\n ...\n        ^     ~~~~~~\np5-var.cpp:98:7: note: bit-field is declared here\n int i : 17; // expected-note{{bit-field is declared here}}\n     ^\n\nllvm-svn: 90992";

local md="f60dc3caa673";

local nd="[C++20][Modules] Adjust handling of exports of namespaces and using-decls.";

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

local pd="Reimplement reference initialization (C++ [dcl.init.ref]) using the";

local vd="Add #pragma clang module begin/end pragmas and generate them when preprocessing a module.\n\nThese pragmas are intended to simulate the effect of entering or leaving a file\nwith an associated module. This is not completely implemented yet: declarations\nbetween the pragmas will not be attributed to the correct module, but macro\nvisibility is already functional.\n\nModules named by #pragma clang module begin must already be known to clang (in\nsome module map that\'s either loaded or on the search path).\n\nllvm-svn: 302098";

local yd="Add #pragma clang module begin/end pragmas and generate them when preprocessing a module.";

[i]={{nil,D,"err_pp_including_mainfile_in_preamble"}},

[h]={{nil,D,"main file cannot be included recursively when building a preamble"}},

[g]={{nil,D,"main file cannot be included recursively when building a preamble"}},

[b]=k,

[e]="main file cannot be included recursively when building a preamble",

[f]=a,

[d]={{nil,D,G}},

[c]={"3c28a2dc6bdc",1557483935,"[Preamble] Stop circular inclusion of main file when building preamble","[Preamble] Stop circular inclusion of main file when building preamble\n\nIf a header file was processed for the second time, we could end up with a\nwrong conditional stack and skipped ranges:\n\nIn the particular example, if the header guard is evaluated the second time and\nit is decided to skip the conditional block, the corresponding \"#endif\" is\nnever seen since the preamble does not include it and we end up in the\nTok.is(tok::eof) case with a wrong conditional stack.\n\nDetect the circular inclusion, emit a diagnostic and stop processing the\ninclusion.\n\nllvm-svn: 360418"},

[j]={{N,2371,"/// Handle either a #include-like directive or an import declaration that names\n/// a header file.\n///\n/// \\param HashLoc The location of the \'#\' token for an include, or\n///        SourceLocation() for an import declaration.\n/// \\param IncludeTok The include / include_next / import token.\n/// \\param FilenameTok The header-name token.\n/// \\param EndLoc The location at which any imported macros become visible.\n/// \\param LookupFrom For #include_next, the starting directory for the\n///        directory lookup.\n/// \\param LookupFromFile For #include_next, the starting file for the directory\n///        lookup.\nPreprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok, SourceLocation EndLoc, ConstSearchDirIterator LookupFrom, const FileEntry *LookupFromFile) {\n  // ...\n  // Check for circular inclusion of the main file.\n  // We can\'t generate a consistent preamble with regard to the conditional\n  // stack if the main file is included again as due to the preamble bounds\n  // some directives (e.g. #endif of a header guard) will never be seen.\n  // Since this will lead to confusing errors, avoid the inclusion.\n  if (Action == Enter && File && PreambleConditionalStack.isRecording() && SourceMgr.isMainFile(File->getFileEntry())) {\n    Diag(FilenameTok.getLocation(), diag::err_pp_including_mainfile_in_preamble);"}}

[i]="err_pp_invalid_directive",

[h]={{nil,y,"invalid preprocessing directive%select{|, did you mean \'#%1\'?}0"},{C,nil,"invalid preprocessing directive"}},

[g]={{nil,y,{"invalid preprocessing directive",{a,", did you mean \'#B\'?"}}},{C,nil,"invalid preprocessing directive"}},

[b]=k,

[e]="invalid preprocessing directive(?:|, did you mean \'\\#(.*?)\'\\?)",

[f]=a,

[d]=G,

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

[j]={{N,1334,"/// 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  Diag(Result, diag::err_pp_invalid_directive) << 0;"}},

[i]="err_pp_invalid_poison",

[b]=k,

[f]=a,

[d]=G,

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

[i]="err_pp_invalid_tok_in_arg_list",

[b]=k,

[f]=a,

[d]=G,

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

[j]={{N,2707,"/// ReadMacroParameterList - The ( starting a parameter list of a macro\n/// definition has just been read.  Lex the rest of the parameters and the\n/// closing ), updating MI with what we learn.  Return true if an error occurs\n/// parsing the param list.\nbool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {\n  // ...\n  while (true) {\n    // ...\n    default:\n      // ...\n      if (!II) {\n        // ...\n        Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);"}}

[i]="err_pp_invalid_udl",

[h]="%select{character|integer}0 literal with user-defined suffix cannot be used in preprocessor constant expression",

[g]={{nil,nil,{{"character","integer"}," literal with user-defined suffix cannot be used in preprocessor constant expression"}}},

[b]=k,

[e]="(?:character|integer) literal with user\\-defined suffix cannot be used in preprocessor constant expression",

[f]=a,

[d]=G,

[c]={"39570d00201c",1331196332,"Add support for cooked forms of user-defined-integer-literal and","Add support for cooked forms of user-defined-integer-literal and\nuser-defined-floating-literal. Support for raw forms of these literals\nto follow.\n\nllvm-svn: 152302"},

[i]="err_pp_line_digit_sequence",

[h]="%select{#line|GNU line marker}0 directive requires a simple digit sequence",

[g]={{nil,nil,{{"#line","GNU line marker"}," directive requires a simple digit sequence"}}},

[b]=k,

[e]="(?:\\#line|GNU line marker) directive requires a simple digit sequence",

[f]=a,

[d]=G,

[c]={"d66f172ab1b6",1240079715,"more fun with line markers: the digit string is required to be interpreted","more fun with line markers: the digit string is required to be interpreted\nas decimal, even if it starts with 0.  Also, since things like 0x1 are\ncompletely illegal, don\'t even bother using numericliteralparser for them.\n\nllvm-svn: 69454"},

[j]={{N,1375,"/// GetLineValue - Convert a numeric token into an unsigned value, emitting\n/// Diagnostic DiagID if it is invalid, and returning the value in Val.\nstatic bool GetLineValue(Token &DigitTok, unsigned &Val, unsigned DiagID, Preprocessor &PP, bool IsGNULineDirective = false) {\n  // ...\n  for (unsigned i = 0; i != ActualLength; ++i) {\n    // ...\n    if (!isDigit(DigitTokBegin[i])) {\n      PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), diag::err_pp_line_digit_sequence) << IsGNULineDirective;"}},

[cd]={"foo:49:5: error: GNU line marker directive requires a simple digit sequence","foo.c:4:8: error: #line directive requires a simple digit sequence","foo.c:5:9: error: #line directive requires a simple digit sequence"}

[i]="err_pp_line_invalid_filename",

[h]="invalid filename for #line directive",

[g]="invalid filename for #line directive",

[b]=k,

[e]="invalid filename for \\#line directive",

[f]=a,

[d]=G,

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

[j]={{N,1436,"/// Handle a \\#line directive: C99 6.10.4.\n///\n/// The two acceptable forms are:\n/// \\verbatim\n///  # line digit-sequence\n///  # line digit-sequence \"s-char-sequence\"\n/// \\endverbatim\nvoid Preprocessor::HandleLineDirective() {\n  // ...\n  // If the StrTok is \"eod\", then it wasn\'t present.  Otherwise, it must be a\n  // string followed by eod.\n  if (StrTok.is(tok::eod))\n  // ...\n  else if (StrTok.isNot(tok::string_literal)) {\n    Diag(StrTok, diag::err_pp_line_invalid_filename);"}},

[cd]={"clang/test/Preprocessor/line-directive.c:42:10: error: invalid filename for #line directive"}

[i]="err_pp_line_requires_integer",

[h]="#line directive requires a positive integer argument",

[g]="#line directive requires a positive integer argument",

[b]=k,

[e]="\\#line directive requires a positive integer argument",

[f]=a,

[d]=G,

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

[j]={{N,1411,"/// Handle a \\#line directive: C99 6.10.4.\n///\n/// The two acceptable forms are:\n/// \\verbatim\n///  # line digit-sequence\n///  # line digit-sequence \"s-char-sequence\"\n/// \\endverbatim\nvoid Preprocessor::HandleLineDirective() {\n  // ...\n  if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer, *this))"}},

[cd]={"clang/test/Preprocessor/line-directive.c:14:7: error: #line directive requires a positive integer argument"}

[i]="err_pp_linemarker_invalid_filename",

[b]=k,

[f]=a,

[d]=G,

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

[j]={{N,1452,"/// Handle a \\#line directive: C99 6.10.4.\n///\n/// The two acceptable forms are:\n/// \\verbatim\n///  # line digit-sequence\n///  # line digit-sequence \"s-char-sequence\"\n/// \\endverbatim\nvoid Preprocessor::HandleLineDirective() {\n  // ...\n  // If the StrTok is \"eod\", then it wasn\'t present.  Otherwise, it must be a\n  // string followed by eod.\n  if (StrTok.is(tok::eod))\n  // ...\n  else if (StrTok.isNot(tok::string_literal)) {\n  // ...\n  } else if (StrTok.hasUDSuffix()) {\n  // ...\n  } else {\n    // ...\n    if (Literal.Pascal) {\n      Diag(StrTok, diag::err_pp_linemarker_invalid_filename);"},{N,1587,"/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is\n/// one of the following forms:\n///\n///    # 42\n///    # 42 \"file\" (\'1\' | \'2\')?\n///    # 42 \"file\" (\'1\' | \'2\')? \'3\' \'4\'?\n///\nvoid Preprocessor::HandleDigitDirective(Token &DigitTok) {\n  // ...\n  // If the StrTok is \"eod\", then it wasn\'t present.  Otherwise, it must be a\n  // string followed by eod.\n  if (StrTok.is(tok::eod)) {\n  // ...\n  } else if (StrTok.isNot(tok::string_literal)) {\n    Diag(StrTok, diag::err_pp_linemarker_invalid_filename);"},{N,1603,"/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is\n/// one of the following forms:\n///\n///    # 42\n///    # 42 \"file\" (\'1\' | \'2\')?\n///    # 42 \"file\" (\'1\' | \'2\')? \'3\' \'4\'?\n///\nvoid Preprocessor::HandleDigitDirective(Token &DigitTok) {\n  // ...\n  // If the StrTok is \"eod\", then it wasn\'t present.  Otherwise, it must be a\n  // string followed by eod.\n  if (StrTok.is(tok::eod)) {\n  // ...\n  } else if (StrTok.isNot(tok::string_literal)) {\n  // ...\n  } else if (StrTok.hasUDSuffix()) {\n  // ...\n  } else {\n    // ...\n    if (Literal.Pascal) {\n      Diag(StrTok, diag::err_pp_linemarker_invalid_filename);"}},

[cd]={"foo:44:6: error: invalid filename for line marker directive","foo:45:6: error: invalid filename for line marker directive"}

[i]="err_pp_linemarker_invalid_flag",

[b]=k,

[f]=a,

[d]=G,

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

[j]={{N,1488,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{N,1496,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  if (FlagVal == 1) {\n    // ...\n    if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{N,1522,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  if (FlagVal == 1) {\n  // ...\n  } else if (FlagVal == 2) {\n    // ...\n    if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{N,1528,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  // We must have 3 if there are still flags.\n  if (FlagVal != 3) {\n    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);"},{N,1537,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{N,1542,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  // We must have 4 if there is yet another flag.\n  if (FlagVal != 4) {\n    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);"},{N,1553,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);"}},

[cd]={"foo:46:14: error: invalid flag line marker directive","foo:47:12: error: invalid flag line marker directive","foo:48:14: error: invalid flag line marker directive"}

[i]="err_pp_linemarker_invalid_pop",

[h]="invalid line marker flag \'2\': cannot pop empty include stack",

[g]="invalid line marker flag \'2\': cannot pop empty include stack",

[b]=k,

[e]="invalid line marker flag \'2\'\\: cannot pop empty include stack",

[f]=a,

[d]=G,

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

[j]={{N,1515,"/// ReadLineMarkerFlags - Parse and validate any flags at the end of a GNU line\n/// marker directive.\nstatic bool ReadLineMarkerFlags(bool &IsFileEntry, bool &IsFileExit, SrcMgr::CharacteristicKind &FileKind, Preprocessor &PP) {\n  // ...\n  if (FlagVal == 1) {\n  // ...\n  } else if (FlagVal == 2) {\n    // ...\n    if (IncLoc.isInvalid() || SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {\n      PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);"}},

[i]="err_pp_linemarker_requires_integer",

[b]=k,

[f]=a,

[d]=G,

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

[j]={{N,1569,"/// HandleDigitDirective - Handle a GNU line marker directive, whose syntax is\n/// one of the following forms:\n///\n///    # 42\n///    # 42 \"file\" (\'1\' | \'2\')?\n///    # 42 \"file\" (\'1\' | \'2\')? \'3\' \'4\'?\n///\nvoid Preprocessor::HandleDigitDirective(Token &DigitTok) {\n  // ...\n  if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer, *this, true))"}}

[i]="err_pp_macro_not_identifier",

[b]=k,

[f]=a,

[d]=G,

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

[j]={{N,329,"bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag) {\n  // ...\n  if (!II)\n    return Diag(MacroNameTok, diag::err_pp_macro_not_identifier);"}},

[i]="err_pp_malformed_ident",

[h]="invalid #ident directive",

[g]="invalid #ident directive",

[b]=k,

[e]="invalid \\#ident directive",

[f]=a,

[d]=G,

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

[j]={{N,1674,"/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.\n///\nvoid Preprocessor::HandleIdentSCCSDirective(Token &Tok) {\n  // ...\n  // If the token kind isn\'t a string, it\'s a malformed directive.\n  if (StrTok.isNot(tok::string_literal) && StrTok.isNot(tok::wide_string_literal)) {\n    Diag(StrTok, diag::err_pp_malformed_ident);"}}

[i]={{nil,A,"err_pp_missing_lparen_in_vaopt_use"}},

[h]={{nil,A,"missing \'(\' following __VA_OPT__"}},

[g]={{nil,A,"missing \'(\' following __VA_OPT__"}},

[b]=k,

[e]="missing \'\\(\' following __VA_OPT__",

[f]=a,

[d]={{nil,A,G}},

[c]={"1826842865f1",1508030786,"[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion)","[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion)\n\nThis patch implements an extension to the preprocessor:\n\n__VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none.\n\n  - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings)\n\n  - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard\'s suggestions.\n\nA few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning.  Given:\n\n    #define F(a,...) a #__VA_OPT__(a ## a)  a ## __VA_OPT__(__VA_ARGS__)\n\n    - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder.\n    - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified.\n    - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT.\n    - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated.\n\nSee wg21.link/P0306 for further details on the feature.\n\n\nAcknowledgment: This patch would have been poorer if not for Richard Smith\'s usual thoughtful analysis and feedback.\nllvm-svn: 315840"},

[j]={{N,2916,"MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {\n  // ...\n  // Read the rest of the macro body.\n  if (MI->isObjectLike()) {\n  // ...\n  } else {\n    // ...\n    while (Tok.isNot(tok::eod)) {\n      // ...\n      if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {\n        // ...\n        if (VAOCtx.isVAOptToken(Tok)) {\n          // ...\n          if (Tok.isNot(tok::l_paren)) {\n            Diag(Tok, diag::err_pp_missing_lparen_in_vaopt_use);"}},

[i]="err_pp_missing_macro_name",

[b]=k,

[f]=a,

[d]=G,

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

[j]={{N,325,"bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag) {\n  // Missing macro name?\n  if (MacroNameTok.is(tok::eod))\n    return Diag(MacroNameTok, diag::err_pp_missing_macro_name);"}},

[i]="err_pp_missing_rparen_in_macro_def",

[h]="missing \')\' in macro parameter list",

[g]="missing \')\' in macro parameter list",

[b]=k,

[e]="missing \'\\)\' in macro parameter list",

[f]=a,

[d]=G,

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

[j]={{N,2690,"/// ReadMacroParameterList - The ( starting a parameter list of a macro\n/// definition has just been read.  Lex the rest of the parameters and the\n/// closing ), updating MI with what we learn.  Return true if an error occurs\n/// parsing the param list.\nbool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {\n  // ...\n  while (true) {\n    // ...\n    case tok::ellipsis: // #define X(... -> C99 varargs\n      // ...\n      if (Tok.isNot(tok::r_paren)) {\n        Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);"},{N,2699,"/// ReadMacroParameterList - The ( starting a parameter list of a macro\n/// definition has just been read.  Lex the rest of the parameters and the\n/// closing ), updating MI with what we learn.  Return true if an error occurs\n/// parsing the param list.\nbool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {\n  // ...\n  while (true) {\n    // ...\n    case tok::eod: // #define X(\n      Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);"},{N,2740,"/// ReadMacroParameterList - The ( starting a parameter list of a macro\n/// definition has just been read.  Lex the rest of the parameters and the\n/// closing ), updating MI with what we learn.  Return true if an error occurs\n/// parsing the param list.\nbool Preprocessor::ReadMacroParameterList(MacroInfo *MI, Token &Tok) {\n  // ...\n  while (true) {\n    // ...\n    default:\n      // ...\n      case tok::ellipsis: // #define X(A... -> GCC extension\n        // ...\n        if (Tok.isNot(tok::r_paren)) {\n          Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);"}}

[i]={{nil,o,"err_pp_module_begin_no_module_map"}},

[h]={{nil,o,"no module map available for module %0"}},

[g]={{nil,o,"no module map available for module A"}},

[b]=k,

[e]="no module map available for module (.*?)",

[f]=a,

[d]={{nil,o,G}},

[c]={wd,1493857794,yd,vd},

[i]={{nil,o,"err_pp_module_begin_no_submodule"}},

[h]={{nil,o,"submodule %0.%1 not declared in module map"}},

[g]={{nil,o,"submodule A.B not declared in module map"}},

[b]=k,

[e]="submodule (.*?)\\.(.*?) not declared in module map",

[f]=a,

[d]={{nil,o,G}},

[c]={wd,1493857794,yd,vd},

[i]={{nil,o,"err_pp_module_begin_without_module_end"}},

[h]={{nil,o,"no matching \'#pragma clang module end\' for this \'#pragma clang module begin\'"}},

[g]={{nil,o,"no matching \'#pragma clang module end\' for this \'#pragma clang module begin\'"}},

[b]=k,

[e]="no matching \'\\#pragma clang module end\' for this \'\\#pragma clang module begin\'",

[f]=a,

[d]={{nil,o,G}},

[c]={wd,1493857794,yd,vd},

[i]={{nil,o,"err_pp_module_begin_wrong_module"}},

[h]={{nil,o,"must specify \'-fmodule-name=%0\' to enter %select{|submodule of }1this module%select{ (current module is %3)|}2"}},

[g]={{nil,o,{"must specify \'-fmodule-name=A\' to enter ",{a,"submodule of "},"this module",{" (current module is D)",a}}}},

[b]=k,

[e]="must specify \'\\-fmodule\\-name\\=(.*?)\' to enter (?:|submodule of )this module(?: \\(current module is (.*?)\\)|)",

[f]=a,

[d]={{nil,o,G}},

[c]={wd,1493857794,yd,vd},

[i]={{nil,o,"err_pp_module_build_missing_end"}},

[h]={{nil,o,"no matching \'#pragma clang module endbuild\' for this \'#pragma clang module build\'"}},

[g]={{nil,o,"no matching \'#pragma clang module endbuild\' for this \'#pragma clang module build\'"}},

[b]=k,

[e]="no matching \'\\#pragma clang module endbuild\' for this \'\\#pragma clang module build\'",

[f]=a,

[d]={{nil,o,G}},

[c]={"5d2ed489870c",1497036152,"Add #pragma clang module build/endbuild pragmas for performing a module build","Add #pragma clang module build/endbuild pragmas for performing a module build\nas part of a compilation.\n\nThis is intended for two purposes:\n\n1) Writing self-contained test cases for modules: we can now write a single\nsource file test that builds some number of module files on the side and\nimports them.\n\n2) Debugging / test case reduction. A single-source testcase is much more\namenable to reduction, compared to a VFS tarball or .pcm files.\n\nllvm-svn: 305101"},

[i]={{nil,o,"err_pp_module_end_without_module_begin"}},

[h]={{nil,o,"no matching \'#pragma clang module begin\' for this \'#pragma clang module end\'"}},

[g]={{nil,o,"no matching \'#pragma clang module begin\' for this \'#pragma clang module end\'"}},

[b]=k,

[e]="no matching \'\\#pragma clang module begin\' for this \'\\#pragma clang module end\'",

[f]=a,

[d]={{nil,o,G}},

[c]={wd,1493857794,yd,vd},

[i]="err_pp_nested_paren",

[h]="nested parentheses not permitted in %0",

[g]="nested parentheses not permitted in A",

[b]=k,

[e]="nested parentheses not permitted in (.*?)",

[f]=a,

[d]=G,

[c]={"50b6ceff1f06",1459845407,"Consolidate and improve the handling of built-in feature-like macros","Consolidate and improve the handling of built-in feature-like macros\n\nSummary:\nThe parsing logic has been separated out from the macro implementation logic, leading to a number of improvements:\n\n* Gracefully handle unexpected/invalid tokens, too few, too many and nested parameters\n* Provide consistent behaviour between all built-in feature-like macros\n* Simplify the implementation of macro logic\n* Fix __is_identifier to correctly return \'0\' for non-identifiers\n\nReviewers: doug.gregor, rsmith\n\nSubscribers: rsmith, cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D17149\n\nllvm-svn: 265381"},

[j]={{Ec,1337,"/// Process single-argument builtin feature-like macros that return\n/// integer values.\nstatic void EvaluateFeatureLikeBuiltinMacro(llvm::raw_svector_ostream &OS, Token &Tok, IdentifierInfo *II, Preprocessor &PP, bool ExpandArgs, llvm::function_ref<int(Token &Tok, bool &HasLexedNextTok)> Op) {\n  // ...\n  already_lexed:\n    // ...\n    case tok::l_paren:\n      // ...\n      if (!SuppressDiagnostic) {\n        PP.Diag(Tok.getLocation(), diag::err_pp_nested_paren) << II;"}},

[i]="err_pp_operator_used_as_macro_name",

[h]="C++ operator %0 (aka %1) used as a macro name",

[g]="C++ operator A (aka B) used as a macro name",

[b]=k,

[e]="C\\+\\+ operator (.*?) \\(aka (.*?)\\) used as a macro name",

[f]=a,

[d]=G,

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

[j]={{N,336,"bool Preprocessor::CheckMacroName(Token &MacroNameTok, MacroUse isDefineUndef, bool *ShadowFlag) {\n  // ...\n  if (II->isCPlusPlusOperatorKeyword()) {\n    // ...\n    Diag(MacroNameTok, getLangOpts().MicrosoftExt ? diag::ext_pp_operator_used_as_macro_name : diag::err_pp_operator_used_as_macro_name) << II << MacroNameTok.getKind();"}},

[i]={{nil,E,"err_pp_pragma_hdrstop_not_seen"}},

[h]={{nil,E,"#pragma hdrstop not seen while attempting to use precompiled header"}},

[g]={{nil,E,"#pragma hdrstop not seen while attempting to use precompiled header"}},

[b]="fatal error\\: ",

[e]="\\#pragma hdrstop not seen while attempting to use precompiled header",

[f]=a,

[d]={{nil,E,G}},

[c]={"58df1affedc0",1536685844,"[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop","[clang-cl, PCH] Support for /Yc and /Yu without filename and #pragma hdrstop\n\nWith clang-cl, when the user specifies /Yc or /Yu without a filename\nthe compiler uses a #pragma hdrstop in the main source file to\ndetermine the end of the PCH. If a header is specified with /Yc or\n/Yu #pragma hdrstop has no effect.\n\nThe optional #pragma hdrstop filename argument is not yet supported.\n\nDifferential Revision: https://reviews.llvm.org/D51391\n\nllvm-svn: 341963"},

[i]="err_pp_pragma_unsafe_buffer_usage_syntax",

[b]=k,

[f]=a,

[d]=G,

[c]={ab,1625925174,bb,cb},

[i]="err_pp_remainder_by_zero",

[b]=k,

[f]=a,

[d]=G,

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

[i]="err_pp_stringize_not_parameter",

[h]="\'%select{#|#@}0\' is not followed by a macro parameter",

[g]={{nil,nil,{uc,{"#","#@"},"\' is not followed by a macro parameter"}}},

[b]=k,

[e]="\'(?:\\#|\\#@)\' is not followed by a macro parameter",

[f]=a,

[d]=G,

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

[j]={{N,2999,"MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {\n  // ...\n  // Read the rest of the macro body.\n  if (MI->isObjectLike()) {\n  // ...\n  } else {\n    // ...\n    while (Tok.isNot(tok::eod)) {\n      // ...\n      // Check for a valid macro arg identifier or __VA_OPT__.\n      if (!VAOCtx.isVAOptToken(Tok) && (Tok.getIdentifierInfo() == nullptr || MI->getParameterNum(Tok.getIdentifierInfo()) == -1)) {\n        // If this is assembler-with-cpp mode, we accept random gibberish after\n        // the \'#\' because \'#\' is often a comment character.  However, change\n        // the kind of the token to tok::unknown so that the preprocessor isn\'t\n        // confused.\n        if (getLangOpts().AsmPreprocessor && Tok.isNot(tok::eod)) {\n        // ...\n        } else {\n          Diag(Tok, diag::err_pp_stringize_not_parameter) << LastTok.is(tok::hashat);"}},

[i]={{nil,O,"err_pp_through_header_not_found"}},

[h]={{nil,O,"\'%0\' required for precompiled header not found"}},

[g]={{nil,O,"\'A\' required for precompiled header not found"}},

[b]="fatal error\\: ",

[e]="\'(.*?)\' required for precompiled header not found",

[f]=a,

[d]={{nil,O,G}},

[c]={"76675de15cfc",1530811333,"[clang-cl, PCH] Implement support for MS-style PCH through headers","[clang-cl, PCH] Implement support for MS-style PCH through headers\n\nImplement support for MS-style PCH through headers.\n\nThis enables support for /Yc and /Yu where the through header is either\non the command line or included in the source. It replaces the current\nsupport the requires the header also be specified with /FI.\n\nThis change adds a -cc1 option -pch-through-header that is used to either\nstart or stop compilation during PCH create or use.\n\nWhen creating a PCH, the compilation ends after compilation of the through\nheader.\n\nWhen using a PCH, tokens are skipped until after the through header is seen.\n\nPatch By: mikerice\nDifferential Revision: https://reviews.llvm.org/D46652\n\nllvm-svn: 336379"},

[i]={{nil,O,"err_pp_through_header_not_seen"}},

[h]={{nil,O,"#include of \'%0\' not seen while attempting to %select{create|use}1 precompiled header"}},

[g]={{nil,O,{"#include of \'A\' not seen while attempting to ",{"create","use"}," precompiled header"}}},

[b]="fatal error\\: ",

[e]="\\#include of \'(.*?)\' not seen while attempting to (?:create|use) precompiled header",

[f]=a,

[d]={{nil,O,G}},

[c]={"76675de15cfc",1530811333,"[clang-cl, PCH] Implement support for MS-style PCH through headers","[clang-cl, PCH] Implement support for MS-style PCH through headers\n\nImplement support for MS-style PCH through headers.\n\nThis enables support for /Yc and /Yu where the through header is either\non the command line or included in the source. It replaces the current\nsupport the requires the header also be specified with /FI.\n\nThis change adds a -cc1 option -pch-through-header that is used to either\nstart or stop compilation during PCH create or use.\n\nWhen creating a PCH, the compilation ends after compilation of the through\nheader.\n\nWhen using a PCH, tokens are skipped until after the through header is seen.\n\nPatch By: mikerice\nDifferential Revision: https://reviews.llvm.org/D46652\n\nllvm-svn: 336379"},

[i]="err_pp_unclosed_pragma_unsafe_buffer_usage",

[h]="\'#pragma unsafe_buffer_usage\' was not ended",

[g]="\'#pragma unsafe_buffer_usage\' was not ended",

[b]=k,

[e]="\'\\#pragma unsafe_buffer_usage\' was not ended",

[f]=a,

[d]=G,

[c]={ab,1625925174,bb,cb},

[i]="err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage",

[h]="not currently inside \'#pragma unsafe_buffer_usage\'",

[g]="not currently inside \'#pragma unsafe_buffer_usage\'",

[b]=k,

[e]="not currently inside \'\\#pragma unsafe_buffer_usage\'",

[f]=a,

[d]=G,

[c]={ab,1625925174,bb,cb},

[i]="err_pp_unmatched_end_of_arc_cf_code_audited",

[h]="not currently inside \'#pragma clang arc_cf_code_audited\'",

[g]="not currently inside \'#pragma clang arc_cf_code_audited\'",

[b]=k,

[e]="not currently inside \'\\#pragma clang arc_cf_code_audited\'",

[f]=a,

[d]=G,

[c]={"32f5fe1467c4",1317359532,"Add explicit attributes to mark functions as having had their","Add explicit attributes to mark functions as having had their\nCoreFoundation object-transfer properties audited, and add a #pragma\nto cause them to be automatically applied to functions in a particular\nspan of code.  This has to be implemented largely in the preprocessor\nbecause of the requirement that the region be entirely contained in\na single file;  that\'s hard to impose from the parser without registering\nfor a ton of callbacks.\n\nllvm-svn: 140846"},

[i]="err_pp_unmatched_end_of_assume_nonnull",

[h]="not currently inside \'#pragma clang assume_nonnull\'",

[g]="not currently inside \'#pragma clang assume_nonnull\'",

[b]=k,

[e]="not currently inside \'\\#pragma clang assume_nonnull\'",

[f]=a,

[d]="Nullability Issue",

[c]={"2a20bd1a9457",1434738357,"Introduced pragmas for audited nullability regions.","Introduced pragmas for audited nullability regions.\n\nIntroduce the clang pragmas \"assume_nonnull begin\" and \"assume_nonnull\nend\" in which we make default assumptions about the nullability of many\nunannotated pointers:\n\n  - Single-level pointers are inferred to __nonnull\n  - NSError** in a (function or method) parameter list is inferred to\n    NSError * __nullable * __nullable.\n  - CFErrorRef * in a (function or method) parameter list is inferred\n    to CFErrorRef __nullable * __nullable.\n  - Other multi-level pointers are never inferred to anything.\n\nImplements rdar://problem/19191042.\n\nllvm-svn: 240156"},

[i]="err_pp_unterminated_conditional",

[b]=k,

[f]=a,

[d]=G,

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

[i]="err_pp_used_poisoned_id",

[b]=k,

[f]=a,

[d]=G,

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

[i]={{nil,A,"err_pp_vaopt_nested_use"}},

[h]={{nil,A,"__VA_OPT__ cannot be nested within its own replacement tokens"}},

[g]={{nil,A,"__VA_OPT__ cannot be nested within its own replacement tokens"}},

[b]=k,

[e]="__VA_OPT__ cannot be nested within its own replacement tokens",

[f]=a,

[d]={{nil,A,G}},

[c]={"1826842865f1",1508030786,"[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion)","[c++2a] Implement P0306 __VA_OPT__ (Comma omission and comma deletion)\n\nThis patch implements an extension to the preprocessor:\n\n__VA_OPT__(contents) --> which expands into its contents if variadic arguments are supplied to the parent macro, or behaves as an empty token if none.\n\n  - Currently this feature is only enabled for C++2a (this could be enabled, with some careful tweaks, for other dialects with the appropriate extension or compatibility warnings)\n\n  - The patch was reviewed here: https://reviews.llvm.org/D35782 and asides from the above (and moving some of the definition and expansion recognition logic into the corresponding state machines), I believe I incorporated all of Richard\'s suggestions.\n\nA few technicalities (most of which were clarified through private correspondence between rsmith, hubert and thomas) are worth mentioning.  Given:\n\n    #define F(a,...) a #__VA_OPT__(a ## a)  a ## __VA_OPT__(__VA_ARGS__)\n\n    - The call F(,) Does not supply any tokens for the variadic arguments and hence VA_OPT behaves as a placeholder.\n    - When expanding VA_OPT (for e.g. F(,1) token pasting occurs eagerly within its contents if the contents need to be stringified.\n    - A hash or a hashhash prior to VA_OPT does not inhibit expansion of arguments if they are the first token within VA_OPT.\n    - When a variadic argument is supplied, argument substitution occurs within the contents as does stringification - and these resulting tokens are inserted back into the macro expansions token stream just prior to the entire stream being rescanned and concatenated.\n\nSee wg21.link/P0306 for further details on the feature.\n\n\nAcknowledgment: This patch would have been poorer if not for Richard Smith\'s usual thoughtful analysis and feedback.\nllvm-svn: 315840"},

[j]={{N,2910,"MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {\n  // ...\n  // Read the rest of the macro body.\n  if (MI->isObjectLike()) {\n  // ...\n  } else {\n    // ...\n    while (Tok.isNot(tok::eod)) {\n      // ...\n      if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {\n        // ...\n        if (VAOCtx.isVAOptToken(Tok)) {\n          // If we\'re already within a VAOPT, emit an error.\n          if (VAOCtx.isInVAOpt()) {\n            Diag(Tok, diag::err_pp_vaopt_nested_use);"}},

[i]="err_pp_visibility_non_macro",

[h]="no macro named %0",

[g]="no macro named A",

[b]=k,

[e]="no macro named (.*?)",

[f]=a,

[d]=G,

[c]={"ebf004990163",1318865549,"For modules, all macros that aren\'t include guards are implicitly","For modules, all macros that aren\'t include guards are implicitly\npublic. Add a __private_macro__ directive to hide a macro, similar to\nthe __module_private__ declaration specifier.\n\nllvm-svn: 142188"},

[j]={{N,1715,"/// Handle a #public directive.\nvoid Preprocessor::HandleMacroPublicDirective(Token &Tok) {\n  // ...\n  // If the macro is not defined, this is an error.\n  if (!MD) {\n    Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;"},{N,1742,"/// Handle a #private directive.\nvoid Preprocessor::HandleMacroPrivateDirective() {\n  // ...\n  // If the macro is not defined, this is an error.\n  if (!MD) {\n    Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;"},{X,2026,"/// This handles parsing pragmas that take a macro name and optional message\nstatic IdentifierInfo *HandleMacroAnnotationPragma(Preprocessor &PP, Token &Tok, const char *Pragma, std::string &MessageString) {\n  // ...\n  if (!II->hasMacroDefinition()) {\n    PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;"},{X,2114,"/// \"\\#pragma clang final(...)\"\n///\n/// The syntax is\n/// \\code\n///  #pragma clang final(MACRO_NAME)\n/// \\endcode\nstruct PragmaFinalHandler : public PragmaHandler {\n  // ...\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    // ...\n    if (!II->hasMacroDefinition()) {\n      PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;"}},

[i]={{nil,C,"err_ppc_builtin_requires_abi"}},

[h]={{nil,C,"this builtin requires ABI -mabi=%0"}},

[g]={{nil,C,"this builtin requires ABI -mabi=A"}},

[b]=k,

[e]="this builtin requires ABI \\-mabi\\=(.*?)",

[f]=a,

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

[c]={hd,1616787805,gd,fd},

[j]={{z,4281,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  // ...\n  case PPC::BI__builtin_pack_longdouble:\n    if (&TI.getLongDoubleFormat() != &llvm::APFloat::PPCDoubleDouble())\n      return Diag(TheCall->getBeginLoc(), diag::err_ppc_builtin_requires_abi) << \"ibmlongdouble\";"}}

[i]={{nil,C,"err_ppc_invalid_test_data_class_type"}},

[h]={{nil,M,"expected a \'float\', \'double\' or \'__float128\' for the first argument"},{y,C,"expected a \'float\' or \'double\' for the first argument"}},

[g]={{nil,M,"expected a \'float\', \'double\' or \'__float128\' for the first argument"},{y,C,"expected a \'float\' or \'double\' for the first argument"}},

[b]=k,

[e]="expected a \'float\', \'double\' or \'__float128\' for the first argument",

[f]=a,

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

[c]={Vc,1615397021,Zc,ad},

[j]={{z,4361,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  // ...\n  case PPC::BI__builtin_ppc_test_data_class: {\n    // ...\n    if (ArgType != QualType(Context.FloatTy) && ArgType != QualType(Context.DoubleTy) && ArgType != QualType(Context.Float128Ty))\n      return Diag(TheCall->getBeginLoc(), diag::err_ppc_invalid_test_data_class_type);"}},

[i]={{nil,v,"err_ppc_invalid_use_mma_type"}},

[h]={{nil,v,"invalid use of PPC MMA type"}},

[g]={{nil,v,"invalid use of PPC MMA type"}},

[b]=k,

[e]="invalid use of PPC MMA type",

[f]=a,

[d]={{nil,v,m}},

[c]={Jb,1590001902,Lb,Mb},

[j]={{z,4410,"#include \"clang/Basic/PPCTypes.def\"\n  ) {\n    Diag(TypeLoc, diag::err_ppc_invalid_use_mma_type);"}},

[i]={{nil,y,"err_pragma_alloc_text_c_linkage"}},

[h]={{nil,y,"\'#pragma alloc_text\' is applicable only to functions with C linkage"}},

[g]={{nil,y,"\'#pragma alloc_text\' is applicable only to functions with C linkage"}},

[b]=k,

[e]="\'\\#pragma alloc_text\' is applicable only to functions with C linkage",

[f]=a,

[d]={{nil,y,m}},

[c]={"cb08f4aa4467",1620530452,"Support warn_unused_result on typedefs","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"},

[i]={{nil,y,"err_pragma_alloc_text_not_function"}},

[h]={{nil,y,"\'#pragma alloc_text\' is applicable only to functions"}},

[g]={{nil,y,"\'#pragma alloc_text\' is applicable only to functions"}},

[b]=k,

[e]="\'\\#pragma alloc_text\' is applicable only to functions",

[f]=a,

[d]={{nil,y,m}},

[c]={ab,1625925174,bb,cb},

[i]={{nil,E,"err_pragma_attr_attr_no_push"}},

[h]={{nil,E,"\'#pragma clang attribute\' attribute with no matching \'#pragma clang attribute push\'"}},

[g]={{nil,E,"\'#pragma clang attribute\' attribute with no matching \'#pragma clang attribute push\'"}},

[b]=k,

[e]="\'\\#pragma clang attribute\' attribute with no matching \'\\#pragma clang attribute push\'",

[f]=a,

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

[c]={"a7cc6b360fe9",1540780161,"Support for groups of attributes in #pragma clang attribute","Support for groups of attributes in #pragma clang attribute\n\nThis commit enables pushing an empty #pragma clang attribute push, then adding\nmultiple attributes to it, then popping them all with #pragma clang attribute\npop, just like #pragma clang diagnostic. We still support the current way of\nadding these, #pragma clang attribute push(__attribute__((...))), by treating it\nlike a combined push/attribute. This is needed to create macros like:\n\nDO_SOMETHING_BEGIN(attr1, attr2, attr3)\n// ...\nDO_SOMETHING_END\n\nrdar://45496947\n\nDifferential revision: https://reviews.llvm.org/D53621\n\nllvm-svn: 345486"},

[i]={{nil,o,"err_pragma_attribute_duplicate_subject"}},

[h]={{nil,o,"duplicate attribute subject matcher \'%0\'"}},

[g]={{nil,o,"duplicate attribute subject matcher \'A\'"}},

[b]=k,

[e]="duplicate attribute subject matcher \'(.*?)\'",

[f]=a,

[d]={{nil,o,x}},

[c]={gb,1492508507,fb,eb},

[j]={{B,1624,"bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) {\n  // ...\n  do {\n    // ...\n    if (isAbstractAttrMatcherRule(PrimaryRule)) {\n    // ...\n    } else if (Parens.consumeOpen()) {\n      if (!SubjectMatchRules.insert(std::make_pair(PrimaryRule, SourceRange(RuleLoc, RuleLoc))).second)\n        Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject) << Name << FixItHint::CreateRemoval(SourceRange(RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleLoc));"},{B,1679,"bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) {\n  // ...\n  do {\n    // ...\n    if (!SubjectMatchRules.insert(std::make_pair(SubRule, SourceRange(RuleLoc, RuleEndLoc))).second) {\n      Diag(RuleLoc, diag::err_pragma_attribute_duplicate_subject) << attr::getSubjectMatchRuleSpelling(SubRule) << FixItHint::CreateRemoval(SourceRange(RuleLoc, Tok.is(tok::comma) ? Tok.getLocation() : RuleEndLoc));"}},

[ob]={"clang/test/Parser/pragma-attribute.cpp:93:91: error: duplicate attribute subject matcher \'function\'","clang/test/Parser/pragma-attribute.cpp:94:91: error: duplicate attribute subject matcher \'function\'","clang/test/Parser/pragma-attribute.cpp:94:101: error: duplicate attribute subject matcher \'function\'","clang/test/Parser/pragma-attribute.cpp:95:97: error: duplicate attribute subject matcher \'function\'","clang/test/Parser/pragma-attribute.cpp:96:87: error: duplicate attribute subject matcher \'enum\'","clang/test/Parser/pragma-attribute.cpp:98:102: error: duplicate attribute subject matcher \'variable(is_global)\'","clang/test/Parser/pragma-attribute.cpp:99:112: error: duplicate attribute subject matcher \'variable(is_global)\'","clang/test/Parser/pragma-attribute.cpp:99:133: error: duplicate attribute subject matcher \'variable(is_global)\'","clang/test/Parser/pragma-attribute.cpp:100:113: error: duplicate attribute subject matcher \'variable(unless(is_parameter))\'","clang/test/Parser/pragma-attribute.cpp:101:113: error: duplicate attribute subject matcher \'variable(unless(is_parameter))\'","clang/test/Parser/pragma-attribute.cpp:101:151: error: duplicate attribute subject matcher \'variable(unless(is_parameter))\'"}

[i]={{nil,o,"err_pragma_attribute_expected_attribute"}},

[h]={{nil,o,"expected an attribute after \'(\'"}},

[g]={{nil,o,"expected an attribute after \'(\'"}},

[b]=k,

[e]="expected an attribute after \'\\(\'",

[f]=a,

[d]={{nil,o,x}},

[c]={gb,1492508507,fb,eb},

[j]={{B,3931,"/// Handle the #pragma clang attribute directive.\n///\n/// The syntax is:\n/// \\code\n///  #pragma clang attribute push (attribute, subject-set)\n///  #pragma clang attribute push\n///  #pragma clang attribute (attribute, subject-set)\n///  #pragma clang attribute pop\n/// \\endcode\n///\n/// There are also \'namespace\' variants of push and pop directives. The bare\n/// \'#pragma clang attribute (attribute, subject-set)\' version doesn\'t require a\n/// namespace, since it always applies attributes to the most recently pushed\n/// group, regardless of namespace.\n/// \\code\n///  #pragma clang attribute namespace.push (attribute, subject-set)\n///  #pragma clang attribute namespace.push\n///  #pragma clang attribute namespace.pop\n/// \\endcode\n///\n/// The subject-set clause defines the set of declarations which receive the\n/// attribute. Its exact syntax is described in the LanguageExtensions document\n/// in Clang\'s documentation.\n///\n/// This directive instructs the compiler to begin/finish applying the specified\n/// attribute to the set of attribute-specific declarations in the active range\n/// of the pragma.\nvoid PragmaAttributeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  // ...\n  // Parse the actual attribute.\n  if ((Info->Action == PragmaAttributeInfo::Push && Tok.isNot(tok::eod)) || Info->Action == PragmaAttributeInfo::Attribute) {\n    // ...\n    if (AttributeTokens.empty()) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_attribute);"}},

[ob]={"clang/test/Parser/pragma-attribute.cpp:109:85: error: expected an attribute after \'(\'","clang/test/Parser/pragma-attribute.cpp:111:31: error: expected an attribute after \'(\'"}

[i]={{nil,o,"err_pragma_attribute_expected_attribute_name"}},

[h]={{nil,o,"expected identifier that represents an attribute name"}},

[g]={{nil,o,"expected identifier that represents an attribute name"}},

[b]=k,

[e]="expected identifier that represents an attribute name",

[f]=a,

[d]={{nil,o,x}},

[c]={gb,1492508507,fb,eb},

[j]={{B,1847,"void Parser::HandlePragmaAttribute() {\n  // ...\n  if ((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) || Tok.isRegularKeywordAttribute()) {\n  // ...\n  } else if (Tok.is(tok::kw___attribute)) {\n    // ...\n    // Parse the comma-separated list of attributes.\n    do {\n      if (Tok.isNot(tok::identifier)) {\n        Diag(Tok, diag::err_pragma_attribute_expected_attribute_name);"}},

[ob]={"clang/test/Parser/pragma-attribute.cpp:121:46: error: expected identifier that represents an attribute name","clang/test/Parser/pragma-attribute.cpp:171:45: error: expected identifier that represents an attribute name","clang/test/Parser/pragma-attribute.cpp:217:65: error: expected identifier that represents an attribute name"}

[i]={{nil,o,"err_pragma_attribute_expected_attribute_syntax"}},

[h]={{nil,o,"expected an attribute that is specified using the GNU, C++11 or \'__declspec\' syntax"}},

[g]={{nil,o,"expected an attribute that is specified using the GNU, C++11 or \'__declspec\' syntax"}},

[b]=k,

[e]="expected an attribute that is specified using the GNU, C\\+\\+11 or \'__declspec\' syntax",

[f]=a,

[d]={{nil,o,x}},

[c]={gb,1492508507,fb,eb},

[j]={{B,1872,"void Parser::HandlePragmaAttribute() {\n  // ...\n  if ((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) || Tok.isRegularKeywordAttribute()) {\n  // ...\n  } else if (Tok.is(tok::kw___attribute)) {\n  // ...\n  } else if (Tok.is(tok::kw___declspec)) {\n  // ...\n  } else {\n    Diag(Tok, diag::err_pragma_attribute_expected_attribute_syntax);"}},

[ob]={"clang/test/Parser/pragma-attribute.cpp:176:31: error: expected an attribute that is specified using the GNU, C++11 or \'__declspec\' syntax","clang/test/Parser/pragma-attribute.cpp:177:31: error: expected an attribute that is specified using the GNU, C++11 or \'__declspec\' syntax","clang/test/Parser/pragma-attribute.cpp:178:31: error: expected an attribute that is specified using the GNU, C++11 or \'__declspec\' syntax","clang/test/Parser/pragma-attribute.cpp:180:31: error: expected an attribute that is specified using the GNU, C++11 or \'__declspec\' syntax"}

[i]={{nil,E,"err_pragma_attribute_expected_period"}},

[h]={{nil,E,"expected \'.\' after pragma attribute namespace %0"}},

[g]={{nil,E,"expected \'.\' after pragma attribute namespace A"}},

[b]=k,

[e]="expected \'\\.\' after pragma attribute namespace (.*?)",

[f]=a,

[d]={{nil,E,x}},

[c]={"0876cae0d749",1545345124,"Add support for namespaces on #pragma clang attribute","Add support for namespaces on #pragma clang attribute\n\nNamespaces are introduced by adding an \"identifier.\" before a\npush/pop directive. Pop directives with namespaces can only pop a\nattribute group that was pushed with the same namespace. Push and pop\ndirectives that don\'t opt into namespaces have the same semantics.\n\nThis is necessary to prevent a pitfall of using multiple #pragma\nclang attribute directives spread out in a large file, particularly\nwhen macros are involved. It isn\'t easy to see which pop corripsonds\nto which push, so its easy to inadvertently pop the wrong group.\n\nDifferential revision: https://reviews.llvm.org/D55628\n\nllvm-svn: 349845"},

[j]={{B,3866,"/// Handle the #pragma clang attribute directive.\n///\n/// The syntax is:\n/// \\code\n///  #pragma clang attribute push (attribute, subject-set)\n///  #pragma clang attribute push\n///  #pragma clang attribute (attribute, subject-set)\n///  #pragma clang attribute pop\n/// \\endcode\n///\n/// There are also \'namespace\' variants of push and pop directives. The bare\n/// \'#pragma clang attribute (attribute, subject-set)\' version doesn\'t require a\n/// namespace, since it always applies attributes to the most recently pushed\n/// group, regardless of namespace.\n/// \\code\n///  #pragma clang attribute namespace.push (attribute, subject-set)\n///  #pragma clang attribute namespace.push\n///  #pragma clang attribute namespace.pop\n/// \\endcode\n///\n/// The subject-set clause defines the set of declarations which receive the\n/// attribute. Its exact syntax is described in the LanguageExtensions document\n/// in Clang\'s documentation.\n///\n/// This directive instructs the compiler to begin/finish applying the specified\n/// attribute to the set of attribute-specific declarations in the active range\n/// of the pragma.\nvoid PragmaAttributeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  // ...\n  // Parse the optional namespace followed by a period.\n  if (Tok.is(tok::identifier)) {\n    // ...\n    if (!II->isStr(\"push\") && !II->isStr(\"pop\")) {\n      // ...\n      if (!Tok.is(tok::period)) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_period) << II;"}},

[ob]={"clang/test/Parser/pragma-attribute.cpp:105:110: error: expected \'.\' after pragma attribute namespace \'pushpop\'"}

[i]={{nil,E,"err_pragma_attribute_expected_push_pop_paren"}},

[h]={{nil,E,"expected \'push\', \'pop\', or \'(\' after \'#pragma clang attribute\'"}},

[g]={{nil,E,"expected \'push\', \'pop\', or \'(\' after \'#pragma clang attribute\'"}},

[b]=k,

[e]="expected \'push\', \'pop\', or \'\\(\' after \'\\#pragma clang attribute\'",

[f]=a,

[d]={{nil,E,x}},

[c]={"a7cc6b360fe9",1540780161,"Support for groups of attributes in #pragma clang attribute","Support for groups of attributes in #pragma clang attribute\n\nThis commit enables pushing an empty #pragma clang attribute push, then adding\nmultiple attributes to it, then popping them all with #pragma clang attribute\npop, just like #pragma clang diagnostic. We still support the current way of\nadding these, #pragma clang attribute push(__attribute__((...))), by treating it\nlike a combined push/attribute. This is needed to create macros like:\n\nDO_SOMETHING_BEGIN(attr1, attr2, attr3)\n// ...\nDO_SOMETHING_END\n\nrdar://45496947\n\nDifferential revision: https://reviews.llvm.org/D53621\n\nllvm-svn: 345486"},

[j]={{B,3876,"/// Handle the #pragma clang attribute directive.\n///\n/// The syntax is:\n/// \\code\n///  #pragma clang attribute push (attribute, subject-set)\n///  #pragma clang attribute push\n///  #pragma clang attribute (attribute, subject-set)\n///  #pragma clang attribute pop\n/// \\endcode\n///\n/// There are also \'namespace\' variants of push and pop directives. The bare\n/// \'#pragma clang attribute (attribute, subject-set)\' version doesn\'t require a\n/// namespace, since it always applies attributes to the most recently pushed\n/// group, regardless of namespace.\n/// \\code\n///  #pragma clang attribute namespace.push (attribute, subject-set)\n///  #pragma clang attribute namespace.push\n///  #pragma clang attribute namespace.pop\n/// \\endcode\n///\n/// The subject-set clause defines the set of declarations which receive the\n/// attribute. Its exact syntax is described in the LanguageExtensions document\n/// in Clang\'s documentation.\n///\n/// This directive instructs the compiler to begin/finish applying the specified\n/// attribute to the set of attribute-specific declarations in the active range\n/// of the pragma.\nvoid PragmaAttributeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  // ...\n  if (!Tok.isOneOf(tok::identifier, tok::l_paren)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_push_pop_paren);"}},

[ob]={"clang/test/Parser/pragma-attribute.cpp:103:109: error: expected \'push\', \'pop\', or \'(\' after \'#pragma clang attribute\'","clang/test/Parser/pragma-attribute.cpp:104:25: error: expected \'push\', \'pop\', or \'(\' after \'#pragma clang attribute\'"}

[i]={{nil,o,"err_pragma_attribute_expected_subject_identifier"}},

[h]={{nil,o,"expected an identifier that corresponds to an attribute subject rule"}},