Module:ClangDiags/DiagsLongData4: Difference between revisions

local b="regex2";

local h="regex3";

local o="Semantic Issue";

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

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

local r="5a8987ca5113";

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

local u="Parse Issue";

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

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

local x="Lexical or Preprocessor Issue";

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

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

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

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

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

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

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

local G="931fcd3ba011";

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

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

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

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

local M="95f50964fbf5";

local N="Add #pragma clang attribute";

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

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

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

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

local T="14f6bfcb52e7";

local U="f881267db9a9";

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

local W="61d065e21ff3";

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

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

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

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

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

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

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

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

local fb="739b410f1ff5";

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

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

local ib="Refactoring Invocation Issue";

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

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

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

local nb="clang/lib/Driver/ToolChains/Arch/ARM.cpp";

local ob="clang/lib/Basic/Targets.cpp";

local pb="3dbcea8b957a";

local qb="f60dc3caa673";

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

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

local tb="f9c3310d32c6";

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

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

local wb="d13863008b38";

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

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

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

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

[h]=a,

[j]=x,

[k]={{C,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  // 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);"}}

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

[h]=a,

[j]=x,

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

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

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

[h]=a,

[j]=x,

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

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

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

[h]=a,

[j]=x,

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

[k]={{C,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  while (true) {\n    default:\n      if (!II) {\n        Diag(Tok, diag::err_pp_invalid_tok_in_arg_list);"}}

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

[h]=a,

[j]=x,

[k]={{"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  case tok::numeric_constant: {\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  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;"}}

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

[h]=a,

[j]=x,

[k]={{C,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  for (unsigned i = 0; i != ActualLength; ++i) {\n    if (!isDigit(DigitTokBegin[i])) {\n      PP.Diag(PP.AdvanceToTokenCharacter(DigitTok.getLocation(), i), diag::err_pp_line_digit_sequence) << IsGNULineDirective;"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  // 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  else if (StrTok.isNot(tok::string_literal)) {\n    Diag(StrTok, diag::err_pp_line_invalid_filename);"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  if (GetLineValue(DigitTok, LineNo, diag::err_pp_line_requires_integer, *this))"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  // 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  else if (StrTok.isNot(tok::string_literal)) {\n  } else if (StrTok.hasUDSuffix()) {\n  } else {\n    if (Literal.Pascal) {\n      Diag(StrTok, diag::err_pp_linemarker_invalid_filename);"},{C,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  // 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  } else if (StrTok.isNot(tok::string_literal)) {\n    Diag(StrTok, diag::err_pp_linemarker_invalid_filename);"},{C,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  // 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  } else if (StrTok.isNot(tok::string_literal)) {\n  } else if (StrTok.hasUDSuffix()) {\n  } else {\n    if (Literal.Pascal) {\n      Diag(StrTok, diag::err_pp_linemarker_invalid_filename);"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{C,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  if (FlagVal == 1) {\n    if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{C,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  if (FlagVal == 1) {\n  } else if (FlagVal == 2) {\n    if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{C,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  // We must have 3 if there are still flags.\n  if (FlagVal != 3) {\n    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);"},{C,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  if (GetLineValue(FlagTok, FlagVal, diag::err_pp_linemarker_invalid_flag, PP))"},{C,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  // We must have 4 if there is yet another flag.\n  if (FlagVal != 4) {\n    PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);"},{C,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  PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_flag);"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  if (FlagVal == 1) {\n  } else if (FlagVal == 2) {\n    if (IncLoc.isInvalid() || SM.getDecomposedExpansionLoc(IncLoc).first != CurFileID) {\n      PP.Diag(FlagTok, diag::err_pp_linemarker_invalid_pop);"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  if (GetLineValue(DigitTok, LineNo, diag::err_pp_linemarker_requires_integer, *this, true))"}}

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

[h]=a,

[j]=x,

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

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

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

[h]=a,

[j]=x,

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

[k]={{C,1674,"/// HandleIdentSCCSDirective - Handle a #ident/#sccs directive.\n///\nvoid Preprocessor::HandleIdentSCCSDirective(Token &Tok) {\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);"}}

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

[h]=a,

[j]=x,

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

[b]="macro name missing",

[h]=a,

[j]=x,

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

[k]={{C,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);"}}

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

[h]=a,

[j]=x,

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

[k]={{C,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  while (true) {\n    case tok::ellipsis: // #define X(... -> C99 varargs\n      if (Tok.isNot(tok::r_paren)) {\n        Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);"},{C,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  while (true) {\n    case tok::eod: // #define X(\n      Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);"},{C,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  while (true) {\n    default:\n      case tok::ellipsis: // #define X(A... -> GCC extension\n        if (Tok.isNot(tok::r_paren)) {\n          Diag(Tok, diag::err_pp_missing_rparen_in_macro_def);"}}

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

[h]=a,

[j]=x,

[c]={wb,1493857794,xb},

[k]={{J,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  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    if (!M) {\n      PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_no_module_map) << Current;"}}

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

[h]=a,

[j]=x,

[c]={wb,1493857794,xb},

[k]={{J,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  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    for (unsigned I = 1; I != ModuleName.size(); ++I) {\n      if (!NewM) {\n        PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule) << M->getFullModuleName() << ModuleName[I].first;"}}

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

[h]=a,

[j]=x,

[c]={wb,1493857794,xb},

[k]={{"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  if ((LeavingSubmodule || IncludeMacroStack.empty()) && !BuildingSubmoduleStack.empty() && BuildingSubmoduleStack.back().IsPragma) {\n    Diag(BuildingSubmoduleStack.back().ImportLoc, diag::err_pp_module_begin_without_module_end);"}}

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

[h]=a,

[j]=x,

[c]={wb,1493857794,xb},

[k]={{J,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  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\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;"}}

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

[h]=a,

[j]=x,

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

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

[h]=a,

[j]=x,

[c]={wb,1493857794,xb},

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

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

[h]=a,

[j]=x,

[k]={{jb,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  already_lexed:\n    case tok::l_paren:\n      if (!SuppressDiagnostic) {\n        PP.Diag(Tok.getLocation(), diag::err_pp_nested_paren) << II;"}}

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

[h]=a,

[j]=x,

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

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

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

[h]=a,

[j]=x,

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

[h]=a,

[j]=x,

[c]={M,1625925174,L},

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

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

[h]=a,

[j]=x,

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

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

[h]=a,

[j]=x,

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

[k]={{C,2999,"MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {\n  // Read the rest of the macro body.\n  if (MI->isObjectLike()) {\n  } else {\n    while (Tok.isNot(tok::eod)) {\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        } else {\n          Diag(Tok, diag::err_pp_stringize_not_parameter) << LastTok.is(tok::hashat);"}}

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

[h]=a,

[j]=x,

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

[h]=a,

[j]=x,

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

[h]=a,

[j]=x,

[c]={M,1625925174,L},

[k]={{"clang/lib/Lex/PPLexerChange.cpp",344,"/// 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  if (IncludeMacroStack.empty() && isPPInSafeBufferOptOutRegion(UnclosedSafeBufferOptOutLoc)) {\n    Diag(UnclosedSafeBufferOptOutLoc, diag::err_pp_unclosed_pragma_unsafe_buffer_usage);"}}

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

[h]=a,

[j]=x,

[c]={M,1625925174,L},

[k]={{J,1269,"struct PragmaUnsafeBufferUsageHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) override {\n    if (II->isStr(\"begin\")) {\n    } else if (II->isStr(\"end\")) {\n      if (PP.enterOrExitSafeBufferOptOutRegion(false, Loc))\n        PP.Diag(Loc, diag::err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage);"}}

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

[h]=a,

[j]=x,

[k]={{J,1906,"/// PragmaARCCFCodeAuditedHandler -\n///  \\#pragma clang arc_cf_code_audited begin/end\nstruct PragmaARCCFCodeAuditedHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &NameTok) override {\n    if (IsBegin) {\n    } else {\n      // Complain about attempts to leave an audit that doesn\'t exist.\n      if (!BeginLoc.isValid()) {\n        PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);"}}

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

[h]=a,

[k]={{J,1964,"/// PragmaAssumeNonNullHandler -\n///  \\#pragma clang assume_nonnull begin/end\nstruct PragmaAssumeNonNullHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &NameTok) override {\n    if (IsBegin) {\n    } else {\n      // Complain about attempts to leave an audit that doesn\'t exist.\n      if (!BeginLoc.isValid()) {\n        PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);"}}

[b]="unterminated conditional directive",

[h]=a,

[j]=x,

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

[k]={{"clang/lib/Lex/Lexer.cpp",3037,"/// LexEndOfFile - CurPtr points to the end of this file.  Handle this\n/// condition, reporting diagnostics and handling other edge cases as required.\n/// This returns true if Result contains a token, false if PP.Lex should be\n/// called again.\nbool Lexer::LexEndOfFile(Token &Result, const char *CurPtr) {\n  // If we are in a #if directive, emit an error.\n  while (!ConditionalStack.empty()) {\n    if (PP->getCodeCompletionFileLoc() != FileLoc)\n      PP->Diag(ConditionalStack.back().IfLoc, diag::err_pp_unterminated_conditional);"}}

[b]="attempt to use a poisoned identifier",

[h]=a,

[j]=x,

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

[k]={{"clang/lib/Lex/Preprocessor.cpp",768,"void Preprocessor::HandlePoisonedIdentifier(Token &Identifier) {\n  if (it == PoisonReasons.end())\n    Diag(Identifier, diag::err_pp_used_poisoned_id);"}}

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

[h]=a,

[j]=x,

[k]={{C,2910,"MacroInfo *Preprocessor::ReadOptionalMacroParameterListAndBody(const Token &MacroNameTok, const bool ImmediatelyAfterHeaderGuard) {\n  // Read the rest of the macro body.\n  if (MI->isObjectLike()) {\n  } else {\n    while (Tok.isNot(tok::eod)) {\n      if (!Tok.isOneOf(tok::hash, tok::hashat, tok::hashhash)) {\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);"}}

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

[h]=a,

[j]=x,

[k]={{C,1715,"/// Handle a #public directive.\nvoid Preprocessor::HandleMacroPublicDirective(Token &Tok) {\n  // If the macro is not defined, this is an error.\n  if (!MD) {\n    Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;"},{C,1742,"/// Handle a #private directive.\nvoid Preprocessor::HandleMacroPrivateDirective() {\n  // If the macro is not defined, this is an error.\n  if (!MD) {\n    Diag(MacroNameTok, diag::err_pp_visibility_non_macro) << II;"},{J,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  if (!II->hasMacroDefinition()) {\n    PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;"},{J,2114,"/// \"\\#pragma clang final(...)\"\n///\n/// The syntax is\n/// \\code\n///  #pragma clang final(MACRO_NAME)\n/// \\endcode\nstruct PragmaFinalHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    if (!II->hasMacroDefinition()) {\n      PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;"}}

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

[h]=a,

[j]=o,

[c]={tb,1616787805,sb},

[k]={{v,4281,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\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\";"}}

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

[h]=a,

[j]=o,

[c]={pb,1615397021,ub},

[k]={{v,4361,"bool Sema::CheckPPCBuiltinFunctionCall(const TargetInfo &TI, unsigned BuiltinID, CallExpr *TheCall) {\n  case PPC::BI__builtin_ppc_test_data_class: {\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);"}}

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

[h]=a,

[j]=o,

[c]={W,1590001902,X},

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

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

[h]=a,

[j]=o,

[k]={{B,816,"void Sema::ActOnPragmaMSAllocText(SourceLocation PragmaLocation, StringRef Section, const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>> &Functions) {\n  for (auto &Function : Functions) {\n    if (getLangOpts().CPlusPlus && !FD->isInExternCContext()) {\n      Diag(Loc, diag::err_pragma_alloc_text_c_linkage);"}}

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

[h]=a,

[j]=o,

[c]={M,1625925174,L},

[k]={{B,811,"void Sema::ActOnPragmaMSAllocText(SourceLocation PragmaLocation, StringRef Section, const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>> &Functions) {\n  for (auto &Function : Functions) {\n    if (!FD) {\n      Diag(Loc, diag::err_pragma_alloc_text_not_function);"}}

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

[h]=a,

[j]=o,

[k]={{B,1066,"void Sema::ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules) {\n  if (PragmaAttributeStack.empty()) {\n    Diag(PragmaLoc, diag::err_pragma_attr_attr_no_push);"}}

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

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1624,"bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) {\n  do {\n    if (isAbstractAttrMatcherRule(PrimaryRule)) {\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));"},{w,1679,"bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) {\n  do {\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));"}}

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

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,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  // Parse the actual attribute.\n  if ((Info->Action == PragmaAttributeInfo::Push && Tok.isNot(tok::eod)) || Info->Action == PragmaAttributeInfo::Attribute) {\n    if (AttributeTokens.empty()) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_attribute);"}}

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

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1847,"void Parser::HandlePragmaAttribute() {\n  if ((Tok.is(tok::l_square) && NextToken().is(tok::l_square)) || Tok.isRegularKeywordAttribute()) {\n  } else if (Tok.is(tok::kw___attribute)) {\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);"}}

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

[h]=a,

[j]=u,

[c]={P,1492508507,N},

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

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

[h]=a,

[j]=u,

[k]={{w,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  // Parse the optional namespace followed by a period.\n  if (Tok.is(tok::identifier)) {\n    if (!II->isStr(\"push\") && !II->isStr(\"pop\")) {\n      if (!Tok.is(tok::period)) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_period) << II;"}}

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

[h]=a,

[j]=u,

[k]={{w,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  if (!Tok.isOneOf(tok::identifier, tok::l_paren)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_expected_push_pop_paren);"}}

[b]="expected an identifier that corresponds to an attribute subject rule",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1602,"bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) {\n  do {\n    if (Name.empty()) {\n      Diag(Tok, diag::err_pragma_attribute_expected_subject_identifier);"}}

[b]="expected an identifier that corresponds to an attribute subject matcher sub\\-rule; \'(.*?)\' matcher (?:does not support sub\\-rules|supports the following sub\\-rules\\: (.*?)|)",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1565,"static void diagnoseExpectedAttributeSubjectSubRule(Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName, SourceLocation SubRuleLoc) {\n  auto Diagnostic = PRef.Diag(SubRuleLoc, diag::err_pragma_attribute_expected_subject_sub_identifier) << PrimaryRuleName;"}}

[b]="extra tokens after attribute in a \'\\#pragma clang attribute push\'",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1957,"void Parser::HandlePragmaAttribute() {\n  // Tokens following an ill-formed attribute will remain in the token stream\n  // and must be removed.\n  if (Tok.isNot(tok::eof)) {\n    Diag(Tok, diag::err_pragma_attribute_extra_tokens_after_attribute);"}}

[b]="unexpected argument \'(.*?)\' to \'\\#pragma clang attribute\'; expected \'push\' or \'pop\'",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,3897,"/// 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  // Determine what action this pragma clang attribute represents.\n  if (Tok.is(tok::l_paren)) {\n  } else {\n    if (II->isStr(\"push\"))\n    else if (II->isStr(\"pop\"))\n    else {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_invalid_argument) << PP.getSpelling(Tok);"}}

[b]="attribute (.*?) can\'t be applied to (.*?)",

[h]=a,

[j]=o,

[c]={P,1492508507,N},

[k]={{B,1048,"void Sema::ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules) {\n  if (!Rules.empty()) {\n    auto Diagnostic = Diag(PragmaLoc, diag::err_pragma_attribute_invalid_matchers) << Attribute;"}}

[b]="expected attribute subject set specifier \'apply_to\'",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1922,"void Parser::HandlePragmaAttribute() {\n  if (Tok.isNot(tok::identifier)) {\n    createExpectedAttributeSubjectRulesTokenDiagnostic(diag::err_pragma_attribute_invalid_subject_set_specifier, Attrs, MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this);"},{w,1930,"void Parser::HandlePragmaAttribute() {\n  if (!II->isStr(\"apply_to\")) {\n    createExpectedAttributeSubjectRulesTokenDiagnostic(diag::err_pragma_attribute_invalid_subject_set_specifier, Attrs, MissingAttributeSubjectRulesRecoveryPoint::ApplyTo, *this);"}}

[b]="negated attribute subject matcher sub\\-rule \'(.*?)\' contradicts sub\\-rule \'(.*?)\'",

[h]=a,

[j]=o,

[c]={P,1492508507,N},

[k]={{B,1036,"void Sema::ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules) {\n  // Figure out which subject matching rules are valid.\n  if (StrictSubjectMatchRuleSet.empty()) {\n    for (const auto &Rule : Rules) {\n      if (It != RulesToFirstSpecifiedNegatedSubRule.end() && It->second != Rule) {\n        Diag(It->second.second.getBegin(), diag::err_pragma_attribute_matcher_negated_subrule_contradicts_subrule) << attr::getSubjectMatchRuleSpelling(attr::SubjectMatchRule(It->second.first)) << attr::getSubjectMatchRuleSpelling(MatchRule) << Rule.second << FixItHint::CreateRemoval(replacementRangeForListElement(*this, It->second.second));"}}

[b]="redundant attribute subject matcher sub\\-rule \'(.*?)\'; \'(.*?)\' already matches those declarations",

[h]=a,

[j]=o,

[c]={P,1492508507,N},

[k]={{B,953,"void Sema::ActOnPragmaAttributeAttribute(ParsedAttr &Attribute, SourceLocation PragmaLoc, attr::ParsedSubjectMatchRuleSet Rules) {\n  // Figure out which subject matching rules are valid.\n  if (StrictSubjectMatchRuleSet.empty()) {\n    for (const auto &Rule : Rules) {\n      if (It != Rules.end()) {\n        Diag(Rule.second.getBegin(), diag::err_pragma_attribute_matcher_subrule_contradicts_rule) << attr::getSubjectMatchRuleSpelling(MatchRule) << attr::getSubjectMatchRuleSpelling(*ParentRule) << It->second << FixItHint::CreateRemoval(replacementRangeForListElement(*this, Rule.second));"}}

[b]="namespace can only apply to \'push\' or \'pop\' directives",

[h]=a,

[j]=u,

[k]={{w,3884,"/// 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  // Determine what action this pragma clang attribute represents.\n  if (Tok.is(tok::l_paren)) {\n    if (Info->Namespace) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_attribute_namespace_on_attribute);"}}

[b]="unterminated \'\\#pragma clang attribute push\' at end of file",

[h]=a,

[j]=o,

[c]={P,1492508507,N},

[k]={{B,1149,"void Sema::DiagnoseUnterminatedPragmaAttribute() {\n  Diag(PragmaAttributeStack.back().Loc, diag::err_pragma_attribute_no_pop_eof);"}}

[b]="\'\\#pragma clang attribute (?:(.*?)\\.|)pop\' with no matching \'\\#pragma clang attribute (?:(.*?)\\.|)push\'",

[h]=a,

[j]=o,

[c]={P,1492508507,N},

[k]={{B,1081,"void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc, const IdentifierInfo *Namespace) {\n  if (PragmaAttributeStack.empty()) {\n    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;"},{B,1095,"void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc, const IdentifierInfo *Namespace) {\n  if (Namespace)\n    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 0 << Namespace->getName();"},{B,1131,"void Sema::ActOnPragmaAttributePop(SourceLocation PragmaLoc, const IdentifierInfo *Namespace) {\n  if (Namespace)\n  else\n    Diag(PragmaLoc, diag::err_pragma_attribute_stack_mismatch) << 1;"}}

[b]="unknown attribute subject rule \'(.*?)\'",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1609,"bool Parser::ParsePragmaAttributeSubjectMatchRuleSet(attr::ParsedSubjectMatchRuleSet &SubjectMatchRules, SourceLocation &AnyLoc, SourceLocation &LastMatchRuleEndLoc) {\n  do {\n    if (!Rule.first) {\n      Diag(Tok, diag::err_pragma_attribute_unknown_subject_rule) << Name;"}}

[b]="(?:invalid use of|unknown) attribute subject matcher sub\\-rule \'(.*?)\'; \'(.*?)\' matcher (?:does not support sub\\-rules|supports the following sub\\-rules\\: (.*?))",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1578,"static void diagnoseUnknownAttributeSubjectSubRule(Parser &PRef, attr::SubjectMatchRule PrimaryRule, StringRef PrimaryRuleName, StringRef SubRuleName, SourceLocation SubRuleLoc) {\n  auto Diagnostic = PRef.Diag(SubRuleLoc, diag::err_pragma_attribute_unknown_subject_sub_rule) << SubRuleName << PrimaryRuleName;"}}

[b]="attribute (.*?) is not supported by \'\\#pragma clang attribute\'",

[h]=a,

[j]=u,

[c]={P,1492508507,N},

[k]={{w,1903,"void Parser::HandlePragmaAttribute() {\n  for (const ParsedAttr &Attribute : Attrs) {\n    if (!Attribute.isSupportedByPragmaAttribute()) {\n      Diag(PragmaLoc, diag::err_pragma_attribute_unsupported_attribute) << Attribute;"}}

[b]="force_cuda_host_device end pragma without matching force_cuda_host_device begin",

[h]=a,

[j]=u,

[k]={{w,3815,"void PragmaForceCUDAHostDeviceHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Info->isStr(\"begin\"))\n  else if (!Actions.PopForceCUDAHostDevice())\n    PP.Diag(FirstTok.getLocation(), diag::err_pragma_cannot_end_force_cuda_host_device);"}}

[b]="expected \'\\=\' following \'\\#pragma clang section (?:invalid|bss|data|rodata|text|relro)\'",

[h]=a,

[j]=u,

[k]={{w,2230,"// #pragma clang section bss=\"abc\" data=\"\" rodata=\"def\" text=\"\" relro=\"\"\nvoid PragmaClangSectionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  while (Tok.isNot(tok::eod)) {\n    if (Tok.isNot(tok::equal)) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_clang_section_expected_equal) << SecKind;"}}

[b]="pragma comment requires parenthesized identifier and optional string",

[h]=a,

[j]=u,

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

[k]={{w,3089,"/// Handle the microsoft \\#pragma comment extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma comment(linker, \"foo\")\n/// \\endcode\n/// \'linker\' is one of five identifiers: compiler, exestr, lib, linker, user.\n/// \"foo\" is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters etc.  See MSDN for more details.\nvoid PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::l_paren)) {\n    PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);"},{w,3096,"/// Handle the microsoft \\#pragma comment extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma comment(linker, \"foo\")\n/// \\endcode\n/// \'linker\' is one of five identifiers: compiler, exestr, lib, linker, user.\n/// \"foo\" is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters etc.  See MSDN for more details.\nvoid PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::identifier)) {\n    PP.Diag(CommentLoc, diag::err_pragma_comment_malformed);"},{w,3137,"/// Handle the microsoft \\#pragma comment extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma comment(linker, \"foo\")\n/// \\endcode\n/// \'linker\' is one of five identifiers: compiler, exestr, lib, linker, user.\n/// \"foo\" is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters etc.  See MSDN for more details.\nvoid PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::r_paren)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);"},{w,3143,"/// Handle the microsoft \\#pragma comment extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma comment(linker, \"foo\")\n/// \\endcode\n/// \'linker\' is one of five identifiers: compiler, exestr, lib, linker, user.\n/// \"foo\" is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters etc.  See MSDN for more details.\nvoid PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::eod)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_comment_malformed);"}}

[b]="unknown kind of pragma comment",

[h]=a,

[j]=u,

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

[k]={{w,3111,"/// Handle the microsoft \\#pragma comment extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma comment(linker, \"foo\")\n/// \\endcode\n/// \'linker\' is one of five identifiers: compiler, exestr, lib, linker, user.\n/// \"foo\" is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters etc.  See MSDN for more details.\nvoid PragmaCommentHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PCK_Unknown) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_comment_unknown_kind);"}}

[b]="pragma detect_mismatch is malformed; it requires two comma\\-separated string literals",

[h]=a,

[j]=u,

[k]={{w,3047,"/// Handle the Microsoft \\#pragma detect_mismatch extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma detect_mismatch(\"name\", \"value\")\n/// \\endcode\n/// Where \'name\' and \'value\' are quoted strings.  The values are embedded in\n/// the object file and passed along to the linker.  If the linker detects a\n/// mismatch in the object file\'s values for the given name, a LNK2038 error\n/// is emitted.  See MSDN for more details.\nvoid PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::comma)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);"},{w,3062,"/// Handle the Microsoft \\#pragma detect_mismatch extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma detect_mismatch(\"name\", \"value\")\n/// \\endcode\n/// Where \'name\' and \'value\' are quoted strings.  The values are embedded in\n/// the object file and passed along to the linker.  If the linker detects a\n/// mismatch in the object file\'s values for the given name, a LNK2038 error\n/// is emitted.  See MSDN for more details.\nvoid PragmaDetectMismatchHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::eod)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_detect_mismatch_malformed);"}}

[b]="expected one of \\[bss\\|data\\|rodata\\|text\\|relro\\] section kind in \'\\#pragma (.*?)\'",

[h]=a,

[j]=u,

[k]={{w,2207,"// #pragma clang section bss=\"abc\" data=\"\" rodata=\"def\" text=\"\" relro=\"\"\nvoid PragmaClangSectionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  while (Tok.isNot(tok::eod)) {\n    if (Tok.isNot(tok::identifier)) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << \"clang section\";"},{w,2223,"// #pragma clang section bss=\"abc\" data=\"\" rodata=\"def\" text=\"\" relro=\"\"\nvoid PragmaClangSectionHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  while (Tok.isNot(tok::eod)) {\n    if (SecType->isStr(\"bss\"))\n    else if (SecType->isStr(\"data\"))\n    else if (SecType->isStr(\"rodata\"))\n    else if (SecType->isStr(\"relro\"))\n    else if (SecType->isStr(\"text\"))\n    else {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_expected_clang_section_name) << \"clang section\";"}}

[b]="\'\\#pragma (.*?)\' can only appear at file scope",

[h]=a,

[j]=o,

[k]={{B,793,"void Sema::ActOnPragmaMSAllocText(SourceLocation PragmaLocation, StringRef Section, const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>> &Functions) {\n  if (!CurContext->getRedeclContext()->isFileContext()) {\n    Diag(PragmaLocation, diag::err_pragma_expected_file_scope) << \"alloc_text\";"},{B,1159,"void Sema::ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn) {\n  if (!CurContext->getRedeclContext()->isFileContext()) {\n    Diag(Loc, diag::err_pragma_expected_file_scope) << \"optimize\";"},{B,1260,"void Sema::ActOnPragmaMSFunction(SourceLocation Loc, const llvm::SmallVectorImpl<StringRef> &NoBuiltins) {\n  if (!CurContext->getRedeclContext()->isFileContext()) {\n    Diag(Loc, diag::err_pragma_expected_file_scope) << \"function\";"}}

[b]="expected an integer argument in \'\\#pragma (.*?)\'",

[h]=a,

[j]=u,

[c]={fb,1570627358,gb},

[k]={{w,3983,"// Handle \'#pragma clang max_tokens 12345\'.\nvoid PragmaMaxTokensHereHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::numeric_constant) || !PP.parseSimpleIntegerLiteral(Tok, MaxTokens)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_expected_integer) << \"clang max_tokens_here\";"},{w,4015,"// Handle \'#pragma clang max_tokens_total 12345\'.\nvoid PragmaMaxTokensTotalHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::numeric_constant) || !PP.parseSimpleIntegerLiteral(Tok, MaxTokens)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_expected_integer) << \"clang max_tokens_total\";"}}

[b]="\'\\#pragma float_control\\(except, on\\)\' is illegal when precise is disabled",

[h]=a,

[j]=o,

[c]={G,1576908663,H},

[k]={{B,579,"void Sema::ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, PragmaFloatControlKind Value) {\n  case PFC_Except:\n    if (!isPreciseFPEnabled())\n      Diag(Loc, diag::err_pragma_fc_except_requires_precise);"}}

[b]="\'\\#pragma float_control\\(precise, off\\)\' is illegal when except is enabled",

[h]=a,

[j]=o,

[c]={G,1576908663,H},

[k]={{B,570,"void Sema::ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, PragmaFloatControlKind Value) {\n  case PFC_NoPrecise:\n    if (CurFPFeatures.getExceptionMode() == LangOptions::FPE_Strict)\n      Diag(Loc, diag::err_pragma_fc_noprecise_requires_noexcept);"}}

[b]="\'\\#pragma float_control\\(precise, off\\)\' is illegal when fenv_access is enabled",

[h]=a,

[j]=o,

[c]={G,1576908663,H},

[k]={{B,572,"void Sema::ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, PragmaFloatControlKind Value) {\n  case PFC_NoPrecise:\n    if (CurFPFeatures.getExceptionMode() == LangOptions::FPE_Strict)\n    else if (CurFPFeatures.getAllowFEnvAccess())\n      Diag(Loc, diag::err_pragma_fc_noprecise_requires_nofenv);"}}

[b]="\'\\#pragma float_control push\\/pop\' can only appear at file or namespace scope or within a language linkage specification",

[h]=a,

[j]=o,

[c]={G,1576908663,H},

[k]={{B,558,"void Sema::ActOnPragmaFloatControl(SourceLocation Loc, PragmaMsStackAction Action, PragmaFloatControlKind Value) {\n  if ((Action == PSK_Push_Set || Action == PSK_Push || Action == PSK_Pop) && !CurContext->getRedeclContext()->isFileContext()) {\n    Diag(Loc, diag::err_pragma_fc_pp_scope);"}}

[b]="\'\\#pragma STDC FENV_ACCESS ON\' is illegal when precise is disabled",

[h]=a,

[j]=o,

[c]={G,1576908663,H},

[k]={{B,1360,"void Sema::ActOnPragmaFEnvAccess(SourceLocation Loc, bool IsEnabled) {\n  if (IsEnabled) {\n    // Verify Microsoft restriction:\n    // You can\'t enable fenv_access unless precise semantics are enabled.\n    // Precise semantics can be enabled either by the float_control\n    // pragma, or by using the /fp:precise or /fp:strict compiler options\n    if (!isPreciseFPEnabled())\n      Diag(Loc, diag::err_pragma_fenv_requires_precise);"}}

[b]="\'\\#pragma (.*?)\' can only appear at file scope or at the start of a compound statement",

[h]=a,

[j]=u,

[k]={{mb,422,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_fp_contract:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << \"fp_contract\";"},{mb,429,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_fp:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << \"clang fp\";"},{mb,437,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_fenv_access_ms:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << (Kind == tok::annot_pragma_fenv_access ? \"STDC FENV_ACCESS\" : \"fenv_access\");"},{mb,446,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_fenv_round:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << \"STDC FENV_ROUND\";"},{mb,453,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_float_control:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << \"float_control\";"}}

[b]="pragma float_control is malformed; use \'float_control\\(\\{push\\|pop\\}\\)\' or \'float_control\\(\\{precise\\|except\\}, \\{on\\|off\\} \\[,push\\]\\)\'",

[h]=a,

[j]=u,