Module:ClangDiags/DiagsLongData4: Difference between revisions

local d="category_hist";

local f="regex3";

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

local o="5.0";

local p="10.0";

local q="11.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 x="Parse Issue";

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 H="clang/lib/Sema/SemaDeclCXX.cpp";

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

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

local K="b1c4d5507fad";

local L="clang/lib/Sema/SemaAttr.cpp";

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 W="function";

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

local Y="clang/test/SemaSYCL/zero-length-arrays.cpp:9:3: error: zero-length arrays are not permitted in SYCL device code";

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 hb="clang/lib/Sema/SemaObjCProperty.cpp";

local ib="11.1";

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

local kb="method";

local lb="14f6bfcb52e7";

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

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 tb="Mass-rename the handful of error_* diagnostics to err_*.\n\nllvm-svn: 288545";

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 Jb="61d065e21ff3";

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

local Lb="Let clang atomic builtins fetch add/sub support floating point 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 Xb="copying variable";

local Yb="copying parameter";

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

local bc="allocating object";

local cc="copying temporary";

local dc="copying array element";

local ec="throwing object";

local fc="copying member subobject";

local gc="initializing base subobject";

local ic="7.1";

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

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 tc="class template";

local uc="\'";

local vc="6d485ff455ea";

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 zc=" option";

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

local Bc="missing";

local Cc="too few ";

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

local Fc="variable template";

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

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

local Uc="__global__";

local Vc="3dbcea8b957a";

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 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 wd="d13863008b38";

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

["err_pp_including_mainfile_in_preamble"]={

[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"}},

[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);"}}

["err_pp_invalid_directive"]={

[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"}},

[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;"}},

["clang/test/Preprocessor/disabled-cond-diags2.c"]={"clang/test/Preprocessor/disabled-cond-diags2.c:14:2: error: invalid preprocessing directive"}

["err_pp_invalid_poison"]={

[i]="err_pp_invalid_poison",

[h]="can only poison identifier tokens",

[g]="can only poison identifier tokens",

[e]="can only poison identifier tokens",

[f]=a,

[d]=G,

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

[j]={{X,461,"/// HandlePragmaPoison - Handle \\#pragma GCC poison. PoisonTok is the \'poison\'.\nvoid Preprocessor::HandlePragmaPoison() {\n  // ...\n  while (true) {\n    // ...\n    // Can only poison identifiers.\n   if (Tok.isNot(tok::raw_identifier)) {\n     Diag(Tok, diag::err_pp_invalid_poison);"}}

["err_pp_invalid_tok_in_arg_list"]={

[i]="err_pp_invalid_tok_in_arg_list",

[h]="invalid token in macro parameter list",

[g]="invalid token in macro parameter list",

[e]="invalid token in macro parameter list",

[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);"}}

["err_pp_invalid_udl"]={

[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"}}},

[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"},

[j]={{"clang/lib/Lex/PPExpressions.cpp",315,"/// 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    // Complain about, and drop, any ud-suffix.\n   if (Literal.hasUDSuffix())\n      PP.Diag(PeekTok, diag::err_pp_invalid_udl) << /*integer*/ 1;"},{"clang/lib/Lex/PPExpressions.cpp",380,"/// 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::char_constant:        // \'x\'\n  case tok::wide_char_constant:    // L\'x\'\n  case tok::utf8_char_constant:    // u8\'x\'\n  case tok::utf16_char_constant:  // u\'x\'\n  case tok::utf32_char_constant: { // U\'x\'\n    // Complain about, and drop, any ud-suffix.\n    if (PeekTok.hasUDSuffix())\n      PP.Diag(PeekTok, diag::err_pp_invalid_udl) << /*character*/ 0;"}},

["clang/test/Parser/cxx11-user-defined-literals.cpp"]={"clang/test/Parser/cxx11-user-defined-literals.cpp:30:5: error: character literal with user-defined suffix cannot be used in preprocessor constant expression","clang/test/Parser/cxx11-user-defined-literals.cpp:30:13: error: character literal with user-defined suffix cannot be used in preprocessor constant expression","clang/test/Parser/cxx11-user-defined-literals.cpp:36:5: error: integer literal with user-defined suffix cannot be used in preprocessor constant expression"}

["err_pp_line_digit_sequence"]={

[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"}}},

[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"}

["err_pp_line_invalid_filename"]={

[i]="err_pp_line_invalid_filename",

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

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

[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"}

["err_pp_line_requires_integer"]={

[i]="err_pp_line_requires_integer",

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

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

[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"}

["err_pp_linemarker_invalid_filename"]={

[i]="err_pp_linemarker_invalid_filename",

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

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

[e]="invalid filename for line marker directive",

[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"}

["err_pp_linemarker_invalid_flag"]={

[i]="err_pp_linemarker_invalid_flag",

[h]="invalid flag line marker directive",

[g]="invalid flag line marker directive",

[e]="invalid flag line marker directive",

[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"}

["err_pp_linemarker_invalid_pop"]={

[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",

[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);"}},

["clang/test/Preprocessor/line-directive-system-headers.c"]={"foo:44:12: error: invalid line marker flag \'2\': cannot pop empty include stack","foo:44:12: error: invalid line marker flag \'2\': cannot pop empty include stack"}

["err_pp_linemarker_requires_integer"]={

[i]="err_pp_linemarker_requires_integer",

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

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

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

[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))"}}

["err_pp_macro_not_identifier"]={

[i]="err_pp_macro_not_identifier",

[h]="macro name must be an identifier",

[g]="macro name must be an identifier",

[e]="macro name must be an identifier",

[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);"}},

["clang/test/Preprocessor/ifdef-recover.c"]={"clang/test/Preprocessor/ifdef-recover.c:9:8: error: macro name must be an identifier","clang/test/Preprocessor/ifdef-recover.c:31:10: error: macro name must be an identifier"}

["err_pp_malformed_ident"]={

[i]="err_pp_malformed_ident",

[h]="invalid #ident directive",

[g]="invalid #ident directive",

[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);"}}

["err_pp_missing_lparen_in_vaopt_use"]={

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

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

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

[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);"}},

["clang/test/Preprocessor/macro_vaopt_check.cpp"]={"clang/test/Preprocessor/macro_vaopt_check.cpp:6:29: error: missing \'(\' following __VA_OPT__"}

["err_pp_missing_macro_name"]={

[i]="err_pp_missing_macro_name",

[h]="macro name missing",

[g]="macro name missing",

[e]="macro name missing",

[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);"}},

["clang/test/Preprocessor/ifdef-recover.c"]={"clang/test/Preprocessor/ifdef-recover.c:5:7: error: macro name missing","clang/test/Preprocessor/ifdef-recover.c:13:12: error: macro name missing","clang/test/Preprocessor/ifdef-recover.c:25:9: error: macro name missing"}

["err_pp_missing_rparen_in_macro_def"]={

[i]="err_pp_missing_rparen_in_macro_def",

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

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

[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);"}}

["err_pp_module_begin_no_module_map"]={

[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"}},

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

[f]=a,

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

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

[j]={{X,1758,"/// Handle the clang \\#pragma module begin extension. The syntax is:\n/// \\code\n///  #pragma clang module begin some.module.name\n///   ...\n///  #pragma clang module end\n/// \\endcode\nstruct PragmaModuleBeginHandler : public PragmaHandler {\n  // ...\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    // ...\n    if (!M) {\n      PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_no_module_map) << Current;"}}

["err_pp_module_begin_no_submodule"]={

[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"}},

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

[f]=a,

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

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

[j]={{X,1764,"/// Handle the clang \\#pragma module begin extension. The syntax is:\n/// \\code\n///  #pragma clang module begin some.module.name\n///   ...\n///   #pragma clang module end\n/// \\endcode\nstruct PragmaModuleBeginHandler : public PragmaHandler {\n  // ...\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    // ...\n    for (unsigned I = 1; I != ModuleName.size(); ++I) {\n      // ...\n      if (!NewM) {\n        PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule) << M->getFullModuleName() << ModuleName[I].first;"}}

["err_pp_module_begin_without_module_end"]={

[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\'"}},

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

[f]=a,

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

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

[j]={{"clang/lib/Lex/PPLexerChange.cpp",353,"/// HandleEndOfFile - This callback is invoked when the lexer hits the end of\n/// the current file. This either returns the EOF token or pops a level off\n/// the include stack and keeps going.\nbool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {\n  // ...\n  if ((LeavingSubmodule || IncludeMacroStack.empty()) && !BuildingSubmoduleStack.empty() && BuildingSubmoduleStack.back().IsPragma) {\n   Diag(BuildingSubmoduleStack.back().ImportLoc, diag::err_pp_module_begin_without_module_end);"}},

["clang/test/Preprocessor/pragma_module.c"]={"clang/test/Preprocessor/pragma_module.c:52:22: error: no matching \'#pragma clang module end\' for this \'#pragma clang module begin\'"}

["err_pp_module_begin_wrong_module"]={

[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}}}},

[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},

[j]={{X,1746,"/// Handle the clang \\#pragma module begin extension. The syntax is:\n/// \\code\n///   #pragma clang module begin some.module.name\n///   ...\n///   #pragma clang module end\n/// \\endcode\nstruct PragmaModuleBeginHandler : public PragmaHandler {\n  // ...\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    // ...\n    if (ModuleName.front().first->getName() != Current) {\n      PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module) << ModuleName.front().first << (ModuleName.size() > 1) << Current.empty() << Current;"}}

["err_pp_module_build_missing_end"]={

[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\'"}},

[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"},

[j]={{X,841,"void Preprocessor::HandlePragmaModuleBuild(Token &Tok) {\n  // ...\n  while (true) {\n    // ...\n    if (Tok.is(tok::eof)) {\n     Diag(Loc, diag::err_pp_module_build_missing_end);"}},

["clang/test/Modules/preprocess-build.cpp"]={"clang/test/Modules/preprocess-build.cpp:35:22: error: no matching \'#pragma clang module endbuild\' for this \'#pragma clang module build\'"}

["err_pp_module_end_without_module_begin"]={

[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\'"}},

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

[f]=a,

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

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

[j]={{X,1802,"/// Handle the clang \\#pragma module end extension.\nstruct PragmaModuleEndHandler : public PragmaHandler {\n  // ...\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n   // ...\n   if (M)\n   // ...\n   else\n     PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);"}},

["clang/test/Modules/preprocess-unavailable.cpp"]={"clang/test/Modules/preprocess-unavailable.cpp:12:22: error: no matching \'#pragma clang module begin\' for this \'#pragma clang module end\'"}

["err_pp_nested_paren"]={

[i]="err_pp_nested_paren",

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

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

[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;"}},

["clang/test/Preprocessor/feature_tests.c"]={"clang/test/Preprocessor/feature_tests.c:122:21: error: nested parentheses not permitted in \'__is_identifier\'"}

["err_pp_operator_used_as_macro_name"]={

[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",

[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();"}},

["clang/test/Preprocessor/cxx_oper_keyword.cpp"]={"clang/test/Preprocessor/cxx_oper_keyword.cpp:16:9: error: C++ operator \'and\' (aka \'&&\') used as a macro name","clang/test/Preprocessor/cxx_oper_keyword.cpp:21:13: error: C++ operator \'xor\' (aka \'^\') used as a macro name","clang/test/Preprocessor/cxx_oper_keyword.cpp:29:8: error: C++ operator \'and\' (aka \'&&\') used as a macro name"}

["err_pp_pragma_hdrstop_not_seen"]={

[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"}},

[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"},

[j]={{"clang/lib/Lex/Preprocessor.cpp",675,"/// Skip tokens until after the #include of the through header or\n/// until after a #pragma hdrstop is seen. Tokens in the predefines file\n/// and the main file may be skipped. If the end of the predefines file\n/// is reached, skipping continues into the main file. If the end of the\n/// main file is reached, it\'s a fatal error.\nvoid Preprocessor::SkipTokensWhileUsingPCH() {\n  // ...\n  if (ReachedMainFileEOF) {\n    if (UsingPCHThroughHeader)\n    // ...\n    else if (!PPOpts->PCHWithHdrStopCreate)\n      Diag(SourceLocation(), diag::err_pp_pragma_hdrstop_not_seen);"}}

[g]="Expected \'begin\' or \'end\'",

[e]="Expected \'begin\' or \'end\'",

[f]=a,

[d]=G,

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

[j]={{X,1257,"struct PragmaUnsafeBufferUsageHandler : public PragmaHandler {\n // ...\n void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) override {\n   // ...\n   if (Tok.isNot(tok::identifier)) {\n     PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);"},{X,1271,"struct PragmaUnsafeBufferUsageHandler : public PragmaHandler {\n // ...\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) override {\n   // ...\n   if (II->isStr(\"begin\")) {\n    // ...\n    } else if (II->isStr(\"end\")) {\n    // ...\n    } else\n      PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);"}},

["clang/test/SemaCXX/warn-unsafe-buffer-usage-pragma-misuse.cpp"]={"clang/test/SemaCXX/warn-unsafe-buffer-usage-pragma-misuse.cpp:21:35: error: Expected \'begin\' or \'end\'","clang/test/SemaCXX/warn-unsafe-buffer-usage-pragma-misuse.cpp:22:35: error: Expected \'begin\' or \'end\'"}

["err_pp_remainder_by_zero"]={

[i]="err_pp_remainder_by_zero",

[h]="remainder by zero in preprocessor expression",

[g]="remainder by zero in preprocessor expression",

[e]="remainder by zero in preprocessor expression",

[f]=a,

[d]=G,

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

[j]={{"clang/lib/Lex/PPExpressions.cpp",709,"/// EvaluateDirectiveSubExpr - Evaluate the subexpression whose first token is\n/// PeekTok, and whose precedence is PeekPrec. This returns the result in LHS.\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, such as division by zero warnings.\nstatic bool EvaluateDirectiveSubExpr(PPValue &LHS, unsigned MinPrec, Token &PeekTok, bool ValueLive, bool &IncludedUndefinedIds, Preprocessor &PP) {\n  // ...\n  while (true) {\n    // ...\n    case tok::percent:\n      if (RHS.Val != 0)\n     // ...\n     else if (ValueLive) {\n       PP.Diag(OpLoc, diag::err_pp_remainder_by_zero) << LHS.getRange() << RHS.getRange();"}}

["err_pp_stringize_not_parameter"]={

[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"}}},

[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);"}},

["clang/test/Preprocessor/stringize_skipped.c"]={"clang/test/Preprocessor/stringize_skipped.c:5:20: error: \'#\' is not followed by a macro parameter"}

["err_pp_through_header_not_found"]={

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

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

[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"},

[j]={{"clang/lib/Lex/Preprocessor.cpp",587,"/// EnterMainSourceFile - Enter the specified FileID as the main source file,\n/// which implicitly adds the builtin defines etc.\nvoid Preprocessor::EnterMainSourceFile() {\n  // ...\n  if (!PPOpts->PCHThroughHeader.empty()) {\n    // ...\n    if (!File) {\n      Diag(SourceLocation(), diag::err_pp_through_header_not_found) << PPOpts->PCHThroughHeader;"}}

[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"}}},

[j]={{"clang/lib/Lex/PPLexerChange.cpp",566,"/// HandleEndOfFile - This callback is invoked when the lexer hits the end of\n/// the current file.  This either returns the EOF token or pops a level off\n/// the include stack and keeps going.\nbool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {\n  // ...\n  if (creatingPCHWithThroughHeader() && !LeavingPCHThroughHeader) {\n    // ...\n    Diag(CurLexer->getFileLoc(), diag::err_pp_through_header_not_seen) << PPOpts->PCHThroughHeader << 0;"},{"clang/lib/Lex/Preprocessor.cpp",672,"/// Skip tokens until after the #include of the through header or\n/// until after a #pragma hdrstop is seen. Tokens in the predefines file\n/// and the main file may be skipped. If the end of the predefines file\n/// is reached, skipping continues into the main file. If the end of the\n/// main file is reached, it\'s a fatal error.\nvoid Preprocessor::SkipTokensWhileUsingPCH() {\n  // ...\n  if (ReachedMainFileEOF) {\n    if (UsingPCHThroughHeader)\n      Diag(SourceLocation(), diag::err_pp_through_header_not_seen) << PPOpts->PCHThroughHeader << 1;"}}