Module:ClangDiags/DiagsLongData4: Difference between revisions

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

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

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

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

[k]={{"clang/lib/Lex/PPExpressions.cpp",298,"/// 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",354,"/// 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;"}}

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

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

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

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

[k]={{C,1358,"/// 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,1367,"/// 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,1392,"/// 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,1398,"/// 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,1408,"/// 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,1413,"/// 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,1425,"/// 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);"}}

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

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

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

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

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

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

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

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

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

[k]={{"clang/lib/Lex/PPLexerChange.cpp",306,"/// 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);"}}

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

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

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

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

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

[k]={{"clang/lib/Lex/Preprocessor.cpp",596,"/// 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  if (ReachedMainFileEOF) {\n    if (UsingPCHThroughHeader)\n    else if (!PPOpts->PCHWithHdrStopCreate)\n      Diag(SourceLocation(), diag::err_pp_pragma_hdrstop_not_seen);"}}

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

[k]={{"clang/lib/Lex/PPExpressions.cpp",688,"/// 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  while (true) {\n    case tok::percent:\n      if (RHS.Val != 0)\n      else if (ValueLive) {\n        PP.Diag(OpLoc, diag::err_pp_remainder_by_zero) << LHS.getRange() << RHS.getRange();"}}

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

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

[k]={{"clang/lib/Lex/PPLexerChange.cpp",488,"/// 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 (creatingPCHWithThroughHeader() && !LeavingPCHThroughHeader) {\n    Diag(CurLexer->getFileLoc(), diag::err_pp_through_header_not_seen) << PPOpts->PCHThroughHeader << 0;"},{"clang/lib/Lex/Preprocessor.cpp",594,"/// 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  if (ReachedMainFileEOF) {\n    if (UsingPCHThroughHeader)\n      Diag(SourceLocation(), diag::err_pp_through_header_not_seen) << PPOpts->PCHThroughHeader << 1;"}}

[k]={{"clang/lib/Lex/PPLexerChange.cpp",300,"/// 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);"}}

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

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

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

[k]={{"clang/lib/Lex/Lexer.cpp",2799,"/// 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);"}}

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

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

[k]={{C,1582,"/// 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,1608,"/// 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,1880,"/// 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,1961,"/// \"\\#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;"}}

[k]={{v,3998,"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\";"}}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[k]={{w,1950,"// #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;"}}

[k]={{w,2714,"/// 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,2721,"/// 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,2753,"/// 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,2759,"/// 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);"}}

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

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

[k]={{w,1927,"// #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,1943,"// #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\";"}}

[k]={{B,654,"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,967,"void Sema::ActOnPragmaMSOptimize(SourceLocation Loc, bool IsOn) {\n  if (!CurContext->getRedeclContext()->isFileContext()) {\n    Diag(Loc, diag::err_pragma_expected_file_scope) << \"optimize\";"},{B,976,"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\";"}}

[k]={{w,3464,"// 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,3489,"// 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\";"}}

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

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

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

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

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

[k]={{mb,395,"#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,402,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_fp:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << \"clang fp\";"},{mb,410,"#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,417,"#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,424,"#include \"clang/Basic/TransformTypeTraits.def\"\n  case tok::annot_pragma_float_control:\n    Diag(Tok, diag::err_pragma_file_or_compound_scope) << \"float_control\";"}}

[k]={{w,2558,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::identifier)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2567,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2571,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n    if (Tok.isNot(tok::r_paren)) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2581,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n  } else {\n    if (Tok.is(tok::r_paren))\n    else if (Tok.isNot(tok::comma)) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2586,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n  } else {\n    if (Tok.is(tok::r_paren))\n    else if (Tok.isNot(tok::comma)) {\n    } else {\n      if (!Tok.isAnyIdentifier()) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2601,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n  } else {\n    if (Tok.is(tok::r_paren))\n    else if (Tok.isNot(tok::comma)) {\n    } else {\n      if (PushOnOff == \"on\")\n      else if (PushOnOff == \"off\") {\n      } else if (PushOnOff == \"push\") {\n      } else {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2608,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n  } else {\n    if (Tok.is(tok::r_paren))\n    else if (Tok.isNot(tok::comma)) {\n    } else {\n      if (Tok.is(tok::comma)) {\n        if (!Tok.isAnyIdentifier()) {\n          PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2615,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n  } else {\n    if (Tok.is(tok::r_paren))\n    else if (Tok.isNot(tok::comma)) {\n    } else {\n      if (Tok.is(tok::comma)) {\n        if (ExpectedPush == \"push\") {\n        } else {\n          PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"},{w,2621,"/// Handle the \\#pragma float_control extension.\n///\n/// The syntax is:\n/// \\code\n///  #pragma float_control(keyword[, setting] [,push])\n/// \\endcode\n/// Where \'keyword\' and \'setting\' are identifiers.\n// \'keyword\' can be: precise, except, push, pop\n// \'setting\' can be: on, off\n/// The optional arguments \'setting\' and \'push\' are supported only\n/// when the keyword is \'precise\' or \'except\'.\nvoid PragmaFloatControlHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Kind == PFC_Unknown) {\n  } else if (Kind == PFC_Push || Kind == PFC_Pop) {\n  } else {\n    if (Tok.is(tok::r_paren))\n    else if (Tok.isNot(tok::comma)) {\n    } else {\n      if (Tok.isNot(tok::r_paren)) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_float_control_malformed);"}}

[k]={{w,2847,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    // Don\'t diagnose if we have an eval_metod pragma with \"double\" kind.\n    if (Tok.isNot(tok::identifier) && !isEvalMethodDouble) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName() << static_cast<int>(*FlagKind);"},{w,2855,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    if (FlagKind == TokFPAnnotValue::Contract) {\n      if (!AnnotValue->ContractValue) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;"},{w,2861,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    if (FlagKind == TokFPAnnotValue::Contract) {\n    } else if (FlagKind == TokFPAnnotValue::Reassociate) {\n      if (!AnnotValue->ReassociateValue) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;"},{w,2867,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    if (FlagKind == TokFPAnnotValue::Contract) {\n    } else if (FlagKind == TokFPAnnotValue::Reassociate) {\n    } else if (FlagKind == TokFPAnnotValue::Exceptions) {\n      if (!AnnotValue->ExceptionsValue) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;"},{w,2873,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    if (FlagKind == TokFPAnnotValue::Contract) {\n    } else if (FlagKind == TokFPAnnotValue::Reassociate) {\n    } else if (FlagKind == TokFPAnnotValue::Exceptions) {\n    } else if (FlagKind == TokFPAnnotValue::EvalMethod) {\n      if (!AnnotValue->EvalMethodValue) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_argument) << PP.getSpelling(Tok) << OptionInfo->getName() << *FlagKind;"}}

[k]={{w,2822,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::identifier)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option) << /*MissingOption=*/true << \"\";"},{w,2832,"void PragmaFPHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    if (!FlagKind) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_fp_invalid_option) << /*MissingOption=*/false << OptionInfo;"}}

[k]={{w,1231,"bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {\n  // Validate the argument.\n  if (StateOption) {\n    if (!Valid) {\n      if (OptionPipelineDisabled) {\n      } else {\n        Diag(Toks[0].getLocation(), diag::err_pragma_invalid_keyword) << /*FullKeyword=*/(OptionUnroll || OptionUnrollAndJam) << /*AssumeSafetyKeyword=*/AssumeSafetyArg;"}}

[k]={{"clang/lib/Sema/SemaStmtAttr.cpp",364,"static void CheckForIncompatibleAttributes(Sema &S, const SmallVectorImpl<const Attr *> &Attrs) {\n  for (const auto *I : Attrs) {\n    if (PrevAttr)\n      S.Diag(OptionLoc, diag::err_pragma_loop_compatibility) << /*Duplicate=*/true << PrevAttr->getDiagnosticName(Policy) << LH->getDiagnosticName(Policy);"},{"clang/lib/Sema/SemaStmtAttr.cpp",371,"static void CheckForIncompatibleAttributes(Sema &S, const SmallVectorImpl<const Attr *> &Attrs) {\n  for (const auto *I : Attrs) {\n    if (CategoryState.StateAttr && CategoryState.NumericAttr && (Category == Unroll || Category == UnrollAndJam || CategoryState.StateAttr->getState() == LoopHintAttr::Disable)) {\n      S.Diag(OptionLoc, diag::err_pragma_loop_compatibility) << /*Duplicate=*/false << CategoryState.StateAttr->getDiagnosticName(Policy) << CategoryState.NumericAttr->getDiagnosticName(Policy);"}}

[k]={{p,3330,"bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {\n  if (!QT->isIntegerType() || QT->isBooleanType() || QT->isCharType()) {\n    Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_type) << QT;"}}

[k]={{p,3342,"bool Sema::CheckLoopHintExpr(Expr *E, SourceLocation Loc) {\n  if (!ValueIsPositive || ValueAPS.getActiveBits() > 31) {\n    Diag(E->getExprLoc(), diag::err_pragma_loop_invalid_argument_value) << toString(ValueAPS, 10) << ValueIsPositive;"}}

[k]={{w,3059,"/// Handle the \\#pragma clang loop directive.\n///  #pragma clang \'loop\' loop-hints\n///\n///  loop-hints:\n///    loop-hint loop-hints[opt]\n///\n///  loop-hint:\n///    \'vectorize\' \'(\' loop-hint-keyword \')\'\n///    \'interleave\' \'(\' loop-hint-keyword \')\'\n///    \'unroll\' \'(\' unroll-hint-keyword \')\'\n///    \'vectorize_predicate\' \'(\' loop-hint-keyword \')\'\n///    \'vectorize_width\' \'(\' loop-hint-value \')\'\n///    \'interleave_count\' \'(\' loop-hint-value \')\'\n///    \'unroll_count\' \'(\' loop-hint-value \')\'\n///    \'pipeline\' \'(\' disable \')\'\n///    \'pipeline_initiation_interval\' \'(\' loop-hint-value \')\'\n///\n///  loop-hint-keyword:\n///    \'enable\'\n///    \'disable\'\n///    \'assume_safety\'\n///\n///  unroll-hint-keyword:\n///    \'enable\'\n///    \'disable\'\n///    \'full\'\n///\n///  loop-hint-value:\n///    constant-expression\n///\n/// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to\n/// try vectorizing the instructions of the loop it precedes. Specifying\n/// interleave(enable) or interleave_count(_value_) instructs llvm to try\n/// interleaving multiple iterations of the loop it precedes. The width of the\n/// vector instructions is specified by vectorize_width() and the number of\n/// interleaved loop iterations is specified by interleave_count(). Specifying a\n/// value of 1 effectively disables vectorization/interleaving, even if it is\n/// possible and profitable, and 0 is invalid. The loop vectorizer currently\n/// only works on inner loops.\n///\n/// The unroll and unroll_count directives control the concatenation\n/// unroller. Specifying unroll(enable) instructs llvm to unroll the loop\n/// completely if the trip count is known at compile time and unroll partially\n/// if the trip count is not known.  Specifying unroll(full) is similar to\n/// unroll(enable) but will unroll the loop only if the trip count is known at\n/// compile time.  Specifying unroll(disable) disables unrolling for the\n/// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the\n/// loop the number of times indicated by the value.\nvoid PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.isNot(tok::identifier)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option) << /*MissingOption=*/true << \"\";"},{w,3069,"/// Handle the \\#pragma clang loop directive.\n///  #pragma clang \'loop\' loop-hints\n///\n///  loop-hints:\n///    loop-hint loop-hints[opt]\n///\n///  loop-hint:\n///    \'vectorize\' \'(\' loop-hint-keyword \')\'\n///    \'interleave\' \'(\' loop-hint-keyword \')\'\n///    \'unroll\' \'(\' unroll-hint-keyword \')\'\n///    \'vectorize_predicate\' \'(\' loop-hint-keyword \')\'\n///    \'vectorize_width\' \'(\' loop-hint-value \')\'\n///    \'interleave_count\' \'(\' loop-hint-value \')\'\n///    \'unroll_count\' \'(\' loop-hint-value \')\'\n///    \'pipeline\' \'(\' disable \')\'\n///    \'pipeline_initiation_interval\' \'(\' loop-hint-value \')\'\n///\n///  loop-hint-keyword:\n///    \'enable\'\n///    \'disable\'\n///    \'assume_safety\'\n///\n///  unroll-hint-keyword:\n///    \'enable\'\n///    \'disable\'\n///    \'full\'\n///\n///  loop-hint-value:\n///    constant-expression\n///\n/// Specifying vectorize(enable) or vectorize_width(_value_) instructs llvm to\n/// try vectorizing the instructions of the loop it precedes. Specifying\n/// interleave(enable) or interleave_count(_value_) instructs llvm to try\n/// interleaving multiple iterations of the loop it precedes. The width of the\n/// vector instructions is specified by vectorize_width() and the number of\n/// interleaved loop iterations is specified by interleave_count(). Specifying a\n/// value of 1 effectively disables vectorization/interleaving, even if it is\n/// possible and profitable, and 0 is invalid. The loop vectorizer currently\n/// only works on inner loops.\n///\n/// The unroll and unroll_count directives control the concatenation\n/// unroller. Specifying unroll(enable) instructs llvm to unroll the loop\n/// completely if the trip count is known at compile time and unroll partially\n/// if the trip count is not known.  Specifying unroll(full) is similar to\n/// unroll(enable) but will unroll the loop only if the trip count is known at\n/// compile time.  Specifying unroll(disable) disables unrolling for the\n/// loop. Specifying unroll_count(_value_) instructs llvm to try to unroll the\n/// loop the number of times indicated by the value.\nvoid PragmaLoopHintHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  while (Tok.is(tok::identifier)) {\n    if (!OptionValid) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_option) << /*MissingOption=*/false << OptionInfo;"}}

[k]={{w,1275,"bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {\n  // Validate the argument.\n  if (StateOption) {\n  } else if (OptionInfo && OptionInfo->getName() == \"vectorize_width\") {\n    // Look for vectorize_width(fixed|scalable)\n    if (IsScalableStr == \"scalable\" || IsScalableStr == \"fixed\") {\n    } else {\n      if (Tok.is(tok::comma)) {\n        if (IsScalableStr != \"scalable\" && IsScalableStr != \"fixed\") {\n          Diag(Tok.getLocation(), diag::err_pragma_loop_invalid_vectorize_option);"}}

[k]={{w,1216,"bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {\n  // Verify loop hint has an argument.\n  if (Toks[0].is(tok::eof)) {\n    Diag(Toks[0].getLocation(), diag::err_pragma_loop_missing_argument) << /*StateArgument=*/StateOption << /*FullKeyword=*/(OptionUnroll || OptionUnrollAndJam) << /*AssumeSafetyKeyword=*/AssumeSafetyArg;"}}

[k]={{"clang/lib/Sema/SemaStmtAttr.cpp",79,"static Attr *handleLoopHintAttr(Sema &S, Stmt *St, const ParsedAttr &A, SourceRange) {\n  // This could be handled automatically by adding a Subjects definition in\n  // Attr.td, but that would make the diagnostic behavior worse in this case\n  // because the user spells this attribute as a pragma.\n  if (!isa<DoStmt, ForStmt, CXXForRangeStmt, WhileStmt>(St)) {\n    S.Diag(St->getBeginLoc(), diag::err_pragma_loop_precedes_nonloop) << Pragma;"}}

[k]={{J,1539,"/// PragmaMessageHandler - Handle the microsoft and gcc \\#pragma message\n/// extension.  The syntax is:\n/// \\code\n///  #pragma message(string)\n/// \\endcode\n/// OR, in GCC mode:\n/// \\code\n///  #pragma message string\n/// \\endcode\n/// string is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters, etc... See MSDN for more details.\n/// Also handles \\#pragma GCC warning and \\#pragma GCC error which take the same\n/// form as \\#pragma message.\nstruct PragmaMessageHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    default:\n      PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;"},{J,1550,"/// PragmaMessageHandler - Handle the microsoft and gcc \\#pragma message\n/// extension.  The syntax is:\n/// \\code\n///  #pragma message(string)\n/// \\endcode\n/// OR, in GCC mode:\n/// \\code\n///  #pragma message string\n/// \\endcode\n/// string is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters, etc... See MSDN for more details.\n/// Also handles \\#pragma GCC warning and \\#pragma GCC error which take the same\n/// form as \\#pragma message.\nstruct PragmaMessageHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    if (ExpectClosingParen) {\n      if (Tok.isNot(tok::r_paren)) {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;"},{J,1557,"/// PragmaMessageHandler - Handle the microsoft and gcc \\#pragma message\n/// extension.  The syntax is:\n/// \\code\n///  #pragma message(string)\n/// \\endcode\n/// OR, in GCC mode:\n/// \\code\n///  #pragma message string\n/// \\endcode\n/// string is a string, which is fully macro expanded, and permits string\n/// concatenation, embedded escape characters, etc... See MSDN for more details.\n/// Also handles \\#pragma GCC warning and \\#pragma GCC error which take the same\n/// form as \\#pragma message.\nstruct PragmaMessageHandler : public PragmaHandler {\n  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override {\n    if (Tok.isNot(tok::eod)) {\n      PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;"}}

[k]={{R,4231,"/// ParseStructUnionBody\n///      struct-contents:\n///        struct-declaration-list\n/// [EXT]  empty\n/// [GNU]  \"struct-declaration-list\" without terminating \';\'\n///      struct-declaration-list:\n///        struct-declaration\n///        struct-declaration-list struct-declaration\n/// [OBC]  \'@\' \'defs\' \'(\' class-name \')\'\n///\nvoid Parser::ParseStructUnionBody(SourceLocation RecordLoc, DeclSpec::TST TagType, RecordDecl *TagDecl) {\n  // While we still have something to read, read the declarations in the struct.\n  while (!tryParseMisplacedModuleImport() && Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) {\n    if (tok::isPragmaAnnotation(Tok.getKind())) {\n      Diag(Tok.getLocation(), diag::err_pragma_misplaced_in_decl) << DeclSpec::getSpecifierName(TagType, Actions.getASTContext().getPrintingPolicy());"},{bb,2954,"Parser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclarationWithPragmas(AccessSpecifier &AS, ParsedAttributes &AccessAttrs, DeclSpec::TST TagType, Decl *TagDecl) {\n  default:\n    if (tok::isPragmaAnnotation(Tok.getKind())) {\n      Diag(Tok.getLocation(), diag::err_pragma_misplaced_in_decl) << DeclSpec::getSpecifierName(TagType, Actions.getASTContext().getPrintingPolicy());"}}

[k]={{w,2776,"// #pragma clang optimize off\n// #pragma clang optimize on\nvoid PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  if (Tok.is(tok::eod)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << \"clang optimize\" << /*Expected=*/true << \"\'on\' or \'off\'\";"},{w,3457,"// Handle \'#pragma clang max_tokens 12345\'.\nvoid PragmaMaxTokensHereHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.is(tok::eod)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << \"clang max_tokens_here\" << /*Expected=*/true << \"integer\";"},{w,3482,"// Handle \'#pragma clang max_tokens_total 12345\'.\nvoid PragmaMaxTokensTotalHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Tok.is(tok::eod)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_missing_argument) << \"clang max_tokens_total\" << /*Expected=*/true << \"integer\";"}}

[k]={{w,2795,"// #pragma clang optimize off\n// #pragma clang optimize on\nvoid PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  if (Tok.isNot(tok::eod)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_extra_argument) << PP.getSpelling(Tok);"}}

[k]={{w,2780,"// #pragma clang optimize off\n// #pragma clang optimize on\nvoid PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  if (Tok.isNot(tok::identifier)) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok);"},{w,2789,"// #pragma clang optimize off\n// #pragma clang optimize on\nvoid PragmaOptimizeHandler::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) {\n  if (II->isStr(\"on\")) {\n  } else if (!II->isStr(\"off\")) {\n    PP.Diag(Tok.getLocation(), diag::err_pragma_optimize_invalid_argument) << PP.getSpelling(Tok);"}}

[k]={{B,192,"void Sema::ActOnPragmaOptionsAlign(PragmaOptionsAlignKind Kind, SourceLocation PragmaLoc) {\n  case POAK_Mac68k:\n    // Check if the target supports this.\n    if (!this->Context.getTargetInfo().hasAlignMac68kSupport()) {\n      Diag(PragmaLoc, diag::err_pragma_options_align_mac68k_target_unsupported);"}}

[k]={{B,267,"void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *alignment) {\n  // XL pragma pack does not support identifier syntax.\n  if (IsXLPragma && !SlotLabel.empty()) {\n    Diag(PragmaLoc, diag::err_pragma_pack_identifer_not_supported);"}}

[k]={{B,291,"void Sema::ActOnPragmaPack(SourceLocation PragmaLoc, PragmaMsStackAction Action, StringRef SlotLabel, Expr *alignment) {\n  if (Alignment) {\n    if (IsXLPragma && *Val == 0) {\n      Diag(PragmaLoc, diag::err_pragma_pack_invalid_alignment);"}}

[k]={{w,1229,"bool Parser::HandlePragmaLoopHint(LoopHint &Hint) {\n  // Validate the argument.\n  if (StateOption) {\n    if (!Valid) {\n      if (OptionPipelineDisabled) {\n        Diag(Toks[0].getLocation(), diag::err_pragma_pipeline_invalid_keyword);"}}

[k]={{w,2367,"/// Handle \'#pragma pointers_to_members\'\n// The grammar for this pragma is as follows:\n//\n// <inheritance model> ::= (\'single\' | \'multiple\' | \'virtual\') \'_inheritance\'\n//\n// #pragma pointers_to_members \'(\' \'best_case\' \')\'\n// #pragma pointers_to_members \'(\' \'full_generality\' [\',\' inheritance-model] \')\'\n// #pragma pointers_to_members \'(\' inheritance-model \')\'\nvoid PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Arg->isStr(\"best_case\")) {\n  } else {\n    if (Arg->isStr(\"full_generality\")) {\n      if (Tok.is(tok::comma)) {\n        if (!Arg) {\n          PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Tok.getKind() << /*OnlyInheritanceModels*/ 0;"},{w,2390,"/// Handle \'#pragma pointers_to_members\'\n// The grammar for this pragma is as follows:\n//\n// <inheritance model> ::= (\'single\' | \'multiple\' | \'virtual\') \'_inheritance\'\n//\n// #pragma pointers_to_members \'(\' \'best_case\' \')\'\n// #pragma pointers_to_members \'(\' \'full_generality\' [\',\' inheritance-model] \')\'\n// #pragma pointers_to_members \'(\' inheritance-model \')\'\nvoid PragmaMSPointersToMembers::HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) {\n  if (Arg->isStr(\"best_case\")) {\n  } else {\n    if (Arg) {\n      if (Arg->isStr(\"single_inheritance\")) {\n      } else if (Arg->isStr(\"multiple_inheritance\")) {\n      } else if (Arg->isStr(\"virtual_inheritance\")) {\n      } else {\n        PP.Diag(Tok.getLocation(), diag::err_pragma_pointers_to_members_unknown_kind) << Arg << /*HasPointerDeclaration*/ 1;"}}

[k]={{B,1167,"void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {\n  if (!VisContext) {\n    Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);"},{B,1187,"void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {\n  if (StartsWithPragma && IsNamespaceEnd) {\n  } else if (!StartsWithPragma && !IsNamespaceEnd) {\n    Diag(EndLoc, diag::err_pragma_pop_visibility_mismatch);"}}

[k]={{J,560,"/// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.\n/// Return the IdentifierInfo* associated with the macro to push or pop.\nIdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {\n  if (Tok.isNot(tok::l_paren)) {\n    Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok);"},{J,567,"/// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.\n/// Return the IdentifierInfo* associated with the macro to push or pop.\nIdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {\n  if (Tok.isNot(tok::string_literal)) {\n    Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok);"},{J,582,"/// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.\n/// Return the IdentifierInfo* associated with the macro to push or pop.\nIdentifierInfo *Preprocessor::ParsePragmaPushOrPopMacro(Token &Tok) {\n  if (Tok.isNot(tok::r_paren)) {\n    Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed) << getSpelling(PragmaTok);"}}

[k]={{B,1177,"void Sema::PopPragmaVisibility(bool IsNamespaceEnd, SourceLocation EndLoc) {\n  if (StartsWithPragma && IsNamespaceEnd) {\n    Diag(Back->second, diag::err_pragma_push_visibility_mismatch);"}}

[k]={{B,250,"void Sema::ActOnPragmaClangSection(SourceLocation PragmaLoc, PragmaClangSectionAction Action, PragmaClangSectionKind SecKind, StringRef SecName) {\n  if (llvm::Error E = isValidSectionSpecifier(SecName)) {\n    Diag(PragmaLoc, diag::err_pragma_section_invalid_for_target) << toString(std::move(E));"}}

[k]={{v,3150,"bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n  if (BuiltinID == BPF::BI__builtin_preserve_field_info) {\n  } else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {\n  } else if (BuiltinID == BPF::BI__builtin_preserve_enum_value) {\n    if (!isValidBPFPreserveEnumValueArg(Arg)) {\n      kind = diag::err_preserve_enum_value_invalid;"}}

[k]={{v,3128,"bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n  if (!Value) {\n    if (BuiltinID == BPF::BI__builtin_preserve_field_info)\n    else if (BuiltinID == BPF::BI__builtin_btf_type_id)\n    else if (BuiltinID == BPF::BI__builtin_preserve_type_info)\n    else\n      kind = diag::err_preserve_enum_value_not_const;"}}

[k]={{v,3122,"bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n  if (!Value) {\n    if (BuiltinID == BPF::BI__builtin_preserve_field_info)\n      kind = diag::err_preserve_field_info_not_const;"}}

[k]={{v,3140,"bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n  if (BuiltinID == BPF::BI__builtin_preserve_field_info) {\n    if (!isValidBPFPreserveFieldInfoArg(Arg)) {\n      kind = diag::err_preserve_field_info_not_field;"}}

[k]={{v,3145,"bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n  if (BuiltinID == BPF::BI__builtin_preserve_field_info) {\n  } else if (BuiltinID == BPF::BI__builtin_preserve_type_info) {\n    if (!isValidBPFPreserveTypeInfoArg(Arg)) {\n      kind = diag::err_preserve_type_info_invalid;"}}

[k]={{v,3126,"bool Sema::CheckBPFBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {\n  if (!Value) {\n    if (BuiltinID == BPF::BI__builtin_preserve_field_info)\n    else if (BuiltinID == BPF::BI__builtin_btf_type_id)\n    else if (BuiltinID == BPF::BI__builtin_preserve_type_info)\n      kind = diag::err_preserve_type_info_not_const;"}}

[k]={{p,2543,"/// The parser has read a name in, and Sema has detected that we\'re currently\n/// inside an ObjC method. Perform some additional checks and determine if we\n/// should form a reference to an ivar.\n///\n/// Ideally, most of this would be done by lookup, but there\'s\n/// actually quite a lot of extra work involved.\nDeclResult Sema::LookupIvarInObjCMethod(LookupResult &Lookup, Scope *S, IdentifierInfo *II) {\n  if (LookForIvars) {\n    if (IFace && (IV = IFace->lookupInstanceVariable(II, ClassDeclared))) {\n      // Diagnose the use of an ivar outside of the declaring class.\n      if (IV->getAccessControl() == ObjCIvarDecl::Private && !declaresSameEntity(ClassDeclared, IFace) && !getLangOpts().DebuggerSupport)\n        Diag(Loc, diag::err_private_ivar_access) << IV->getDeclName();"},{I,1185,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  // Handle ivar access to Objective-C objects.\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {\n    if (IV->getAccessControl() != ObjCIvarDecl::Public && IV->getAccessControl() != ObjCIvarDecl::Package) {\n      if (!S.getLangOpts().DebuggerSupport) {\n        if (IV->getAccessControl() == ObjCIvarDecl::Private) {\n          if (!declaresSameEntity(ClassDeclared, IDecl) || !declaresSameEntity(ClassOfMethodDecl, ClassDeclared))\n            S.Diag(MemberLoc, diag::err_private_ivar_access) << IV->getDeclName();"}}

[k]={{Z,2196,"/// Parse a declaration beginning with the \'module\' keyword or C++20\n/// context-sensitive keyword (optionally preceded by \'export\').\n///\n///  module-declaration:  [C++20]\n///    \'export\'[opt] \'module\' module-name attribute-specifier-seq[opt] \';\'\n///\n///  global-module-fragment:  [C++2a]\n///    \'module\' \';\' top-level-declaration-seq[opt]\n///  module-declaration:      [C++2a]\n///    \'export\'[opt] \'module\' module-name module-partition[opt]\n///            attribute-specifier-seq[opt] \';\'\n///  private-module-fragment: [C++2a]\n///    \'module\' \':\' \'private\' \';\' top-level-declaration-seq[opt]\nParser::DeclGroupPtrTy Parser::ParseModuleDecl(Sema::ModuleImportState &ImportState) {\n  // Parse a private-module-fragment, if present.\n  if (getLangOpts().CPlusPlusModules && Tok.is(tok::colon) && NextToken().is(tok::kw_private)) {\n    ExpectAndConsumeSemi(diag::err_private_module_fragment_expected_semi);"}}

[k]={{"clang/lib/Sema/SemaModule.cpp",395,"Sema::DeclGroupPtrTy Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc) {\n  case Module::ModuleHeaderUnit:\n    Diag(PrivateLoc, diag::err_private_module_fragment_not_module);"}}

[k]={{"clang/lib/Sema/SemaModule.cpp",404,"Sema::DeclGroupPtrTy Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc) {\n  case Module::ModuleImplementationUnit:\n    Diag(PrivateLoc, diag::err_private_module_fragment_not_module_interface);"}}

[k]={{"clang/lib/Sema/SemaModule.cpp",399,"Sema::DeclGroupPtrTy Sema::ActOnPrivateModuleFragmentDecl(SourceLocation ModuleLoc, SourceLocation PrivateLoc) {\n  case Module::PrivateModuleFragment:\n    Diag(PrivateLoc, diag::err_private_module_fragment_redefined);"}}

[k]={{v,2169,"#include \"clang/Basic/Builtins.def\"\n  case Builtin::BI__builtin_expect_with_probability: {\n    if ((!ProbArg->EvaluateAsConstantExpr(Eval, Context)) || !Eval.Val.isFloat()) {\n      Diag(ProbArg->getBeginLoc(), diag::err_probability_not_constant_float) << ProbArg->getSourceRange();"}}

[k]={{v,2178,"#include \"clang/Basic/Builtins.def\"\n  case Builtin::BI__builtin_expect_with_probability: {\n    if (!(Probability >= llvm::APFloat(0.0) && Probability <= llvm::APFloat(1.0))) {\n      Diag(ProbArg->getBeginLoc(), diag::err_probability_out_of_range) << ProbArg->getSourceRange();"}}

[k]={{Q,1378,"bool Sema::DiagnosePropertyAccessorMismatch(ObjCPropertyDecl *property, ObjCMethodDecl *GetterMethod, SourceLocation Loc) {\n  if (!compat) {\n    if ((propertyObjCPtr = PropertyRValueType->getAs<ObjCObjectPointerType>()) && (getterObjCPtr = GetterType->getAs<ObjCObjectPointerType>()))\n    else if (CheckAssignmentConstraints(Loc, GetterType, PropertyRValueType) != Compatible) {\n      Diag(Loc, diag::err_property_accessor_type) << property->getDeclName() << PropertyRValueType << GetterMethod->getSelector() << GetterType;"}}

[k]={{I,1146,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  // Handle ivar access to Objective-C objects.\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {\n    if (!IV) {\n      if (TypoCorrection Corrected = S.CorrectTypo(R.getLookupNameInfo(), Sema::LookupMemberName, nullptr, nullptr, Validator, Sema::CTK_ErrorRecovery, IDecl)) {\n      } else {\n        if (IsArrow && IDecl->FindPropertyDeclaration(Member, ObjCPropertyQueryKind::OBJC_PR_query_instance)) {\n          S.Diag(MemberLoc, diag::err_property_found_suggest) << Member << BaseExpr.get()->getType() << FixItHint::CreateReplacement(OpLoc, \".\");"}}

[k]={{"clang/lib/Sema/SemaPseudoObject.cpp",581,"void ObjCPropertyOpBuilder::DiagnoseUnsupportedPropertyUse() {\n  if (S.getCurLexicalContext()->isObjCContainer() && S.getCurLexicalContext()->getDeclKind() != Decl::ObjCCategoryImpl && S.getCurLexicalContext()->getDeclKind() != Decl::ObjCImplementation) {\n    if (ObjCPropertyDecl *prop = RefExpr->getExplicitProperty()) {\n      S.Diag(RefExpr->getLocation(), diag::err_property_function_in_objc_container);"}}

[k]={{Q,1258,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  if (IC) {\n    if (ObjCPropertyImplDecl *PPIDecl = IC->FindPropertyImplDecl(PropertyId, QueryKind)) {\n      Diag(PropertyLoc, diag::err_property_implemented) << PropertyId;"},{Q,1289,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  if (IC) {\n  } else {\n    if (ObjCPropertyImplDecl *PPIDecl = CatImplClass->FindPropertyImplDecl(PropertyId, QueryKind)) {\n      Diag(PropertyDiagLoc, diag::err_property_implemented) << PropertyId;"}}

[k]={{"clang/lib/Sema/SemaTemplateInstantiateDecl.cpp",1084,"Decl *TemplateDeclInstantiator::VisitMSPropertyDecl(MSPropertyDecl *D) {\n  if (DI->getType()->isVariablyModifiedType()) {\n    SemaRef.Diag(D->getLocation(), diag::err_property_is_variably_modified) << D;"}}

[k]={{Q,1124,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    // Check that type of property and its ivar are type compatible.\n    if (!Context.hasSameType(PropertyIvarType, IvarType)) {\n      if (!compat) {\n        Diag(PropertyDiagLoc, diag::err_property_ivar_type) << property->getDeclName() << PropType << Ivar->getDeclName() << IvarType;"},{Q,1135,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    // Check that type of property and its ivar are type compatible.\n    if (!Context.hasSameType(PropertyIvarType, IvarType)) {\n      if (!compat) {\n      } else {\n        if (lhsType != rhsType && lhsType->isArithmeticType()) {\n          Diag(PropertyDiagLoc, diag::err_property_ivar_type) << property->getDeclName() << PropType << Ivar->getDeclName() << IvarType;"}}

[k]={{"clang/lib/Sema/SemaAvailability.cpp",382,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    diag = !ObjCPropertyAccess ? diag::err_unavailable : diag::err_property_method_unavailable;"}}

[k]={{db,1728,"/// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an\n/// objective C interface.  This is a property reference expression.\nExprResult Sema::HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, Expr *BaseExpr, SourceLocation OpLoc, DeclarationName MemberName, SourceLocation MemberLoc, SourceLocation SuperLoc, QualType SuperType, bool Super) {\n  if (ObjCIvarDecl *Ivar = IFace->lookupInstanceVariable(Member, ClassDeclared)) {\n    if (const ObjCObjectPointerType *OBJPT = T->getAsObjCInterfacePointerType()) {\n      if (RequireCompleteType(MemberLoc, OBJPT->getPointeeType(), diag::err_property_not_as_forward_class, MemberName, BaseExpr))"}}

[k]={{I,1270,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {\n    // id, with and without qualifiers.\n    if (OT->isObjCId()) {\n      return ExprError(S.Diag(MemberLoc, diag::err_property_not_found) << MemberName << BaseType);"},{I,1317,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {\n    // \'Class\', unqualified only.\n    if (OT->isObjCClass()) {\n      return ExprError(S.Diag(MemberLoc, diag::err_property_not_found) << MemberName << BaseType);"},{db,1735,"/// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an\n/// objective C interface.  This is a property reference expression.\nExprResult Sema::HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, Expr *BaseExpr, SourceLocation OpLoc, DeclarationName MemberName, SourceLocation MemberLoc, SourceLocation SuperLoc, QualType SuperType, bool Super) {\n  Diag(MemberLoc, diag::err_property_not_found) << MemberName << QualType(OPT, 0);"},{db,1823,"ExprResult Sema::ActOnClassPropertyRefExpr(IdentifierInfo &receiverName, IdentifierInfo &propertyName, SourceLocation receiverNameLoc, SourceLocation propertyNameLoc) {\n  return ExprError(Diag(propertyNameLoc, diag::err_property_not_found) << &propertyName << Context.getObjCInterfaceType(IFace));"}}

[k]={{db,1622,"/// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an\n/// objective C interface.  This is a property reference expression.\nExprResult Sema::HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, Expr *BaseExpr, SourceLocation OpLoc, DeclarationName MemberName, SourceLocation MemberLoc, SourceLocation SuperLoc, QualType SuperType, bool Super) {\n  if (RequireCompleteType(MemberLoc, OPT->getPointeeType(), diag::err_property_not_found_forward_class, MemberName, BaseRange))"}}

[k]={{db,1720,"/// HandleExprPropertyRefExpr - Handle foo.bar where foo is a pointer to an\n/// objective C interface.  This is a property reference expression.\nExprResult Sema::HandleExprPropertyRefExpr(const ObjCObjectPointerType *OPT, Expr *BaseExpr, SourceLocation OpLoc, DeclarationName MemberName, SourceLocation MemberLoc, SourceLocation SuperLoc, QualType SuperType, bool Super) {\n  if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(MemberName, MemberLoc), LookupOrdinaryName, nullptr, nullptr, CCC, CTK_ErrorRecovery, IFace, false, OPT)) {\n    if (TypoResult.isIdentifier() && TypoResult.getAsIdentifierInfo() == Member) {\n    } else {\n      diagnoseTypo(Corrected, PDiag(diag::err_property_not_found_suggest) << MemberName << QualType(OPT, 0));"}}

[k]={{"clang/lib/Sema/SemaPseudoObject.cpp",561,"/// Try to find the most accurate setter declaration for the property\n/// reference.\n///\n/// \\return true if a setter was found, in which case Setter\nbool ObjCPropertyOpBuilder::findSetter(bool warn) {\n  // Do a normal method lookup first.\n  if (ObjCMethodDecl *setter = LookupMethodInReceiverType(S, SetterSelector, RefExpr)) {\n    if (setter->isPropertyAccessor() && warn)\n      if (const ObjCInterfaceDecl *IFace = dyn_cast<ObjCInterfaceDecl>(setter->getDeclContext())) {\n        if (ObjCPropertyDecl *prop1 = IFace->FindPropertyDeclaration(AltMember, prop->getQueryKind()))\n          if (prop != prop1 && (prop1->getSetterMethodDecl() == setter)) {\n            S.Diag(RefExpr->getExprLoc(), diag::err_property_setter_ambiguous_use) << prop << prop1 << setter->getSelector();"}}

[k]={{Q,516,"ObjCPropertyDecl *Sema::CreatePropertyDecl(Scope *S, ObjCContainerDecl *CDecl, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, const unsigned Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TInfo, tok::ObjCKeywordKind MethodImplKind, DeclContext *lexicalDC) {\n  if (T->isArrayType() || T->isFunctionType()) {\n    Diag(AtLoc, diag::err_property_type) << T;"}}

[k]={{I,1188,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  // Handle ivar access to Objective-C objects.\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {\n    if (IV->getAccessControl() != ObjCIvarDecl::Public && IV->getAccessControl() != ObjCIvarDecl::Package) {\n      if (!S.getLangOpts().DebuggerSupport) {\n        if (IV->getAccessControl() == ObjCIvarDecl::Private) {\n        } else if (!IDecl->isSuperClassOf(ClassOfMethodDecl))\n          S.Diag(MemberLoc, diag::err_protected_ivar_access) << IV->getDeclName();"}}

[k]={{Y,950,"bool Sema::CheckForwardProtocolDeclarationForCircularDependency(IdentifierInfo *PName, SourceLocation &Ploc, SourceLocation PrevLoc, const ObjCList<ObjCProtocolDecl> &PList) {\n  for (ObjCList<ObjCProtocolDecl>::iterator I = PList.begin(), E = PList.end(); I != E; ++I) {\n    if (ObjCProtocolDecl *PDecl = LookupProtocol((*I)->getIdentifier(), Ploc)) {\n      if (PDecl->getIdentifier() == PName) {\n        Diag(Ploc, diag::err_protocol_has_circular_dependency);"}}

[k]={{Q,789,"/// SelectPropertyForSynthesisFromProtocols - Finds the most appropriate\n/// property declaration that should be synthesised in all of the inherited\n/// protocols. It also diagnoses properties declared in inherited protocols with\n/// mismatched types or attributes, since any of them can be candidate for\n/// synthesis.\nstatic ObjCPropertyDecl *SelectPropertyForSynthesisFromProtocols(Sema &S, SourceLocation AtLoc, ObjCInterfaceDecl *ClassDecl, ObjCPropertyDecl *Property) {\n  // Diagnose incompability.\n  {\n    auto Diag = S.Diag(Property->getLocation(), Property != OriginalProperty || HasIncompatibleAttributes ? diag::err_protocol_property_mismatch : diag::warn_protocol_property_mismatch);"}}

[k]={{E,6736,"ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeTypeInfo, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage Destructed) {\n  if (!ObjectType->isDependentType() && !ObjectType->isScalarType() && !ObjectType->isVectorType()) {\n    if (getLangOpts().MSVCCompat && ObjectType->isVoidType())\n    else {\n      Diag(OpLoc, diag::err_pseudo_dtor_base_not_scalar) << ObjectType << Base->getSourceRange();"}}

[k]={{p,6112,"/// BuildCallExpr - Handle a call to Fn with the specified array of arguments.\n/// This provides the location of the left/right parens and a list of comma\n/// locations.\nExprResult Sema::BuildCallExpr(Scope *Scope, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n  if (getLangOpts().CPlusPlus) {\n    // If this is a pseudo-destructor expression, build the call immediately.\n    if (isa<CXXPseudoDestructorExpr>(Fn)) {\n      if (!ArgExprs.empty()) {\n        Diag(Fn->getBeginLoc(), diag::err_pseudo_dtor_call_with_args) << FixItHint::CreateRemoval(SourceRange(ArgExprs.front()->getBeginLoc(), ArgExprs.back()->getEndLoc()));"}}

[k]={{E,6844,"ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName) {\n  if (SecondTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {\n    if (!T && ((SS.isSet() && !computeDeclContext(SS, false)) || (!SS.isSet() && ObjectType->isDependentType()))) {\n    } else if (!T) {\n      Diag(SecondTypeName.StartLocation, diag::err_pseudo_dtor_destructor_non_type) << SecondTypeName.Identifier << ObjectType;"},{E,6881,"ExprResult Sema::ActOnPseudoDestructorExpr(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, CXXScopeSpec &SS, UnqualifiedId &FirstTypeName, SourceLocation CCLoc, SourceLocation TildeLoc, UnqualifiedId &SecondTypeName) {\n  if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_TemplateId || FirstTypeName.Identifier) {\n    if (FirstTypeName.getKind() == UnqualifiedIdKind::IK_Identifier) {\n      if (!T) {\n        Diag(FirstTypeName.StartLocation, diag::err_pseudo_dtor_destructor_non_type) << FirstTypeName.Identifier << ObjectType;"}}

[k]={{E,6764,"ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeTypeInfo, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage Destructed) {\n  // C++ [expr.pseudo]p2:\n  //  [...] The cv-unqualified versions of the object type and of the type\n  //  designated by the pseudo-destructor-name shall be the same type.\n  if (DestructedTypeInfo) {\n    if (!DestructedType->isDependentType() && !ObjectType->isDependentType()) {\n      if (!Context.hasSameUnqualifiedType(DestructedType, ObjectType)) {\n        // Detect dot pseudo destructor calls on pointer objects, e.g.:\n        //  Foo *foo;\n        //  foo.~Foo();\n        if (OpKind == tok::period && ObjectType->isPointerType() && Context.hasSameUnqualifiedType(DestructedType, ObjectType->getPointeeType())) {\n        } else {\n          Diag(DestructedTypeStart, diag::err_pseudo_dtor_type_mismatch) << ObjectType << DestructedType << Base->getSourceRange() << DestructedTypeInfo->getTypeLoc().getSourceRange();"},{E,6799,"ExprResult Sema::BuildPseudoDestructorExpr(Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, const CXXScopeSpec &SS, TypeSourceInfo *ScopeTypeInfo, SourceLocation CCLoc, SourceLocation TildeLoc, PseudoDestructorTypeStorage Destructed) {\n  // C++ [expr.pseudo]p2:\n  //  [...] Furthermore, the two type-names in a pseudo-destructor-name of the\n  //  form\n  //\n  //    ::[opt] nested-name-specifier[opt] type-name :: ~ type-name\n  //\n  //  shall designate the same scalar type.\n  if (ScopeTypeInfo) {\n    if (!ScopeType->isDependentType() && !ObjectType->isDependentType() && !Context.hasSameUnqualifiedType(ScopeType, ObjectType)) {\n      Diag(ScopeTypeInfo->getTypeLoc().getSourceRange().getBegin(), diag::err_pseudo_dtor_type_mismatch) << ObjectType << ScopeType << Base->getSourceRange() << ScopeTypeInfo->getTypeLoc().getSourceRange();"}}

[k]={{y,15502,"void Sema::ActOnPureSpecifier(Decl *D, SourceLocation ZeroLoc) {\n  if (D->getFriendObjectKind())\n    Diag(D->getLocation(), diag::err_pure_friend);"}}

[k]={{y,14302,"/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch\n/// handler.\nDecl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {\n  if (D.getCXXScopeSpec().isSet() && !Invalid) {\n    Diag(D.getIdentifierLoc(), diag::err_qualified_catch_declarator) << D.getCXXScopeSpec().getRange();"}}

[k]={{y,15066,"NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams) {\n  if ((SS.isInvalid() || !SS.isSet()) && (FunctionContainingLocalClass = cast<CXXRecordDecl>(CurContext)->isLocalClass())) {\n  } else if (SS.isInvalid() || !SS.isSet()) {\n  } else if (!SS.getScopeRep()->isDependent()) {\n    if (D.isFunctionDefinition()) {\n      SemaDiagnosticBuilder DB = Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def);"},{y,15085,"NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams) {\n  if ((SS.isInvalid() || !SS.isSet()) && (FunctionContainingLocalClass = cast<CXXRecordDecl>(CurContext)->isLocalClass())) {\n  } else if (SS.isInvalid() || !SS.isSet()) {\n  } else if (!SS.getScopeRep()->isDependent()) {\n  } else {\n    if (D.isFunctionDefinition()) {\n      Diag(SS.getRange().getBegin(), diag::err_qualified_friend_def) << SS.getScopeRep();"}}

[k]={{t,7910,"/// Generate diagnostics for an invalid function redeclaration.\n///\n/// This routine handles generating the diagnostic messages for an invalid\n/// function redeclaration, including finding possible similar declarations\n/// or performing typo correction if there are no previous declarations with\n/// the same name.\n///\n/// Returns a NamedDecl iff typo correction was performed and substituting in\n/// the new declaration name does not cause new errors.\nstatic NamedDecl *DiagnoseInvalidRedeclaration(Sema &SemaRef, LookupResult &Previous, FunctionDecl *NewFD, ActOnFDArgs &ExtraArgs, bool IsLocalFriend, Scope *S) {\n  unsigned DiagMsg = IsLocalFriend ? diag::err_no_matching_local_friend : NewFD->getFriendObjectKind() ? diag::err_qualified_friend_no_match : diag::err_member_decl_does_not_match;"},{q,7800,"/// Perform semantic analysis for the given function template\n/// specialization.\n///\n/// This routine performs all of the semantic analysis required for an\n/// explicit function template specialization. On successful completion,\n/// the function declaration \\p FD will become a function template\n/// specialization.\n///\n/// \\param FD the function declaration, which will be updated to become a\n/// function template specialization.\n///\n/// \\param ExplicitTemplateArgs the explicitly-provided template arguments,\n/// if any. Note that this may be valid info even when 0 arguments are\n/// explicitly provided as in, e.g., \\c void sort<>(char*, char*);\n/// as it anyway contains info on the angle brackets locations.\n///\n/// \\param Previous the set of declarations that may be specialized by\n/// this function specialization.\n///\n/// \\param QualifiedFriend whether this is a lookup for a qualified friend\n/// declaration with no explicit template argument list that might be\n/// befriending a function template specialization.\nbool Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend) {\n  // For a qualified friend declaration (with no explicit marker to indicate\n  // that a template specialization was intended), note all (template and\n  // non-template) candidates.\n  if (QualifiedFriend && Candidates.empty()) {\n    Diag(FD->getLocation(), diag::err_qualified_friend_no_match) << FD->getDeclName() << FDLookupContext;"}}

[k]={{F,1889,"bool Sema::CheckQualifiedFunctionForTypeId(QualType T, SourceLocation Loc) {\n  Diag(Loc, diag::err_qualified_function_typeid) << T << getFunctionQualifiersAsString(FPT);"}}

[k]={{I,589,"static bool LookupMemberExprInRecord(Sema &SemaRef, LookupResult &R, Expr *BaseExpr, const RecordType *RTy, SourceLocation OpLoc, bool IsArrow, CXXScopeSpec &SS, bool HasTemplateArgs, SourceLocation TemplateKWLoc, TypoExpr *&TE) {\n  if (SS.isSet()) {\n    if (!isa<TypeDecl>(DC)) {\n      SemaRef.Diag(R.getNameLoc(), diag::err_qualified_member_nonclass) << DC << SS.getRange();"}}

[k]={{I,468,"/// We know that the given qualified member reference points only to\n/// declarations which do not belong to the static type of the base\n/// expression.  Diagnose the problem.\nstatic void DiagnoseQualifiedMemberReference(Sema &SemaRef, Expr *BaseExpr, QualType BaseType, const CXXScopeSpec &SS, NamedDecl *rep, const DeclarationNameInfo &nameInfo) {\n  SemaRef.Diag(nameInfo.getLoc(), diag::err_qualified_member_of_unrelated) << SS.getRange() << rep << BaseType;"}}

[k]={{I,1093,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  // Handle ivar access to Objective-C objects.\n  if (const ObjCObjectType *OTy = BaseType->getAs<ObjCObjectType>()) {\n    if (!SS.isEmpty() && !SS.isInvalid()) {\n      S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access) << 1 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());"},{I,1227,"/// Look up the given member of the given non-type-dependent\n/// expression.  This can return in one of two ways:\n///  * If it returns a sentinel null-but-valid result, the caller will\n///    assume that lookup was performed and the results written into\n///    the provided structure.  It will take over from there.\n///  * Otherwise, the returned expression will be produced in place of\n///    an ordinary member expression.\n///\n/// The ObjCImpDecl bit is a gross hack that will need to be properly\n/// fixed for ObjC++.\nstatic ExprResult LookupMemberExpr(Sema &S, LookupResult &R, ExprResult &BaseExpr, bool &IsArrow, SourceLocation OpLoc, CXXScopeSpec &SS, Decl *ObjCImpDecl, bool HasTemplateArgs, SourceLocation TemplateKWLoc) {\n  if (!IsArrow && (OPT = BaseType->getAs<ObjCObjectPointerType>())) {\n    if (!SS.isEmpty() && !SS.isInvalid()) {\n      S.Diag(SS.getRange().getBegin(), diag::err_qualified_objc_access) << 0 << SS.getScopeRep() << FixItHint::CreateRemoval(SS.getRange());"}}

[k]={{Y,4351,"Decl *Sema::ActOnObjCExceptionDecl(Scope *S, Declarator &D) {\n  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).\n  if (D.getCXXScopeSpec().isSet()) {\n    Diag(D.getIdentifierLoc(), diag::err_qualified_objc_catch_parm) << D.getCXXScopeSpec().getRange();"}}

[k]={{t,12830,"/// Common checks for a parameter-declaration that should apply to both function\n/// parameters and non-type template parameters.\nvoid Sema::CheckFunctionOrTemplateParamDeclarator(Scope *S, Declarator &D) {\n  // Parameter declarators cannot be qualified (C++ [dcl.meaning]p1).\n  if (D.getCXXScopeSpec().isSet()) {\n    Diag(D.getIdentifierLoc(), diag::err_qualified_param_declarator) << D.getCXXScopeSpec().getRange();"}}

[k]={{t,5912,"NamedDecl *Sema::ActOnTypedefDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous) {\n  // Typedef declarators cannot be qualified (C++ [dcl.meaning]p1).\n  if (D.getCXXScopeSpec().isSet()) {\n    Diag(D.getIdentifierLoc(), diag::err_qualified_typedef_declarator) << D.getCXXScopeSpec().getRange();"}}

[k]={{K,2518,"/// BuildCXXForRangeStmt - Build or instantiate a C++11 for-range statement.\nStmtResult Sema::BuildCXXForRangeStmt(SourceLocation ForLoc, SourceLocation CoawaitLoc, Stmt *InitStmt, SourceLocation ColonLoc, Stmt *RangeDecl, Stmt *Begin, Stmt *End, Expr *Cond, Expr *Inc, Stmt *LoopVarDecl, SourceLocation RParenLoc, BuildForRangeKind Kind) {\n  if (RangeVarType->isDependentType()) {\n  } else if (!BeginDeclStmt.get()) {\n    if (const ArrayType *UnqAT = RangeType->getAsArrayTypeUnsafe()) {\n    } else {\n      if (Kind == BFRK_Build && RangeStatus == FRS_NoViableFunction && BEFFailure == BEF_begin) {\n        // If the range is being built from an array parameter, emit a\n        // a diagnostic that it is being treated as a pointer.\n        if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Range)) {\n          if (ParmVarDecl *PVD = dyn_cast<ParmVarDecl>(DRE->getDecl())) {\n            if (PointerTy->isPointerType() && ArrayTy->isArrayType()) {\n              Diag(Range->getBeginLoc(), diag::err_range_on_array_parameter) << RangeLoc << PVD << ArrayTy << PointerTy;"}}

[k]={{"clang/lib/Lex/Lexer.cpp",1955,"/// LexRawStringLiteral - Lex the remainder of a raw string literal, after\n/// having lexed R\", LR\", u8R\", uR\", or UR\".\nbool Lexer::LexRawStringLiteral(Token &Result, const char *CurPtr, tok::TokenKind Kind) {\n  // If the last character was not a \'(\', then we didn\'t lex a valid delimiter.\n  if (CurPtr[PrefixLen] != \'(\') {\n    if (!isLexingRawMode()) {\n      if (PrefixLen == 16) {\n        Diag(PrefixEnd, diag::err_raw_delim_too_long);"}}

[k]={{p,12378,"/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue.  If not,\n/// emit an error and return true.  If so, return false.\nstatic bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) {\n  case Expr::MLV_InvalidMessageExpression:\n    DiagID = diag::err_readonly_message_assignment;"}}

[k]={{p,4264,"static QualType CheckRealImagOperand(Sema &S, ExprResult &V, SourceLocation Loc, bool IsReal) {\n  S.Diag(Loc, diag::err_realimag_invalid_type) << V.get()->getType() << (IsReal ? \"__real\" : \"__imag\");"}}

[k]={{t,8420,"static void checkIsValidOpenCLKernelParameter(Sema &S, Declarator &D, ParmVarDecl *Param, llvm::SmallPtrSetImpl<const Type *> &ValidTypes) {\n  do {\n    for (const auto *FD : RD->fields()) {\n      // OpenCL v1.2 s6.9.p:\n      // Arguments to kernel functions that are declared to be a struct or union\n      // do not allow OpenCL objects to be passed as elements of the struct or\n      // union. This restriction was lifted in OpenCL v2.0 with the introduction\n      // of SVM.\n      if (ParamType == PtrKernelParam || ParamType == PtrPtrKernelParam || ParamType == InvalidAddrSpacePtrKernelParam) {\n        S.Diag(Param->getLocation(), diag::err_record_with_pointers_kernel_param) << PT->isUnionType() << PT;"}}

[k]={{p,5237,"bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *RewrittenInit, bool SkipImmediateInvocations) {\n  if (Param->hasUnparsedDefaultArg()) {\n    // If we\'ve already cleared out the location for the default argument,\n    // that means we\'re parsing it right now.\n    if (!UnparsedDefaultArgLocs.count(Param)) {\n      Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;"},{"clang/lib/Sema/SemaTemplateInstantiate.cpp",2229,"/// Substitute the given template arguments into the default argument.\nbool Sema::SubstDefaultArgument(SourceLocation Loc, ParmVarDecl *Param, const MultiLevelTemplateArgumentList &TemplateArgs, bool ForCallExpr) {\n  if (Inst.isAlreadyInstantiating()) {\n    Diag(Param->getBeginLoc(), diag::err_recursive_default_argument) << FD;"}}

[k]={{Y,477,"void Sema::ActOnSuperClassOfClassInterface(Scope *S, SourceLocation AtInterfaceLoc, ObjCInterfaceDecl *IDecl, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange) {\n  if (declaresSameEntity(PrevDecl, IDecl)) {\n    Diag(SuperLoc, diag::err_recursive_superclass) << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);"}}

[k]={{t,3922,"static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old) {\n  S.Diag(New->getLocation(), New->isThisDeclarationADefinition() ? diag::err_redefinition_different_type : diag::err_redeclaration_different_type) << New->getDeclName() << New->getType() << Old->getType();"}}

[k]={{t,1542,"// [module.interface]p6:\n// A redeclaration of an entity X is implicitly exported if X was introduced by\n// an exported declaration; otherwise it shall not be exported.\nbool Sema::CheckRedeclarationExported(NamedDecl *New, NamedDecl *Old) {\n  Diag(New->getLocation(), diag::err_redeclaration_non_exported) << New << S;"}}

[k]={{t,2453,"/// MergeTypedefNameDecl - We just parsed a typedef \'New\' which has the\n/// same name and scope as a previous declaration \'Old\'.  Figure out\n/// how to resolve this situation, merging decls or emitting\n/// diagnostics as appropriate. If there was an error, set New to be invalid.\n///\nvoid Sema::MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls) {\n  if (getLangOpts().CPlusPlus) {\n    Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();"},{t,2749,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {\n      if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {\n      } else {\n        unsigned Diag = cast<VarDecl>(Def)->isThisDeclarationADefinition() == VarDecl::TentativeDefinition ? diag::err_alias_after_tentative : diag::err_redefinition;"},{t,2751,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<AliasAttr>(NewAttribute) || isa<IFuncAttr>(NewAttribute)) {\n      if (FunctionDecl *FD = dyn_cast<FunctionDecl>(New)) {\n      } else {\n        if (Diag == diag::err_redefinition)"},{t,4187,"/// MergeVarDecl - We just parsed a variable \'New\' which has the same name\n/// and scope as a previous declaration \'Old\'.  Figure out how to resolve this\n/// situation, merging decls or emitting diagnostics as appropriate.\n///\n/// Tentative definition rules (C99 6.9.2p2) are checked by\n/// FinalizeDeclaratorGroup. Unfortunately, we can\'t analyze tentative\n/// definitions here, since the initializer hasn\'t been attached.\n///\nvoid Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {\n  // FIXME: The test for external storage here seems wrong? We still\n  // need to check for mismatches.\n  if (!New->hasExternalStorage() && !New->isFileVarDecl() &&\n    Diag(New->getLocation(), diag::err_redefinition) << New->getDeclName();"},{t,4324,"/// We\'ve just determined that \\p Old and \\p New both appear to be definitions\n/// of the same variable. Either diagnose or fix the problem.\nbool Sema::checkVarDeclRedefinition(VarDecl *Old, VarDecl *New) {\n  if (!hasVisibleDefinition(Old) && (New->getFormalLinkage() == InternalLinkage || New->isInline() || isa<VarTemplateSpecializationDecl>(New) || New->getDescribedVarTemplate() || New->getNumTemplateParameterLists() || New->getDeclContext()->isDependentContext())) {\n  } else {\n    Diag(New->getLocation(), diag::err_redefinition) << New;"},{t,13236,"void Sema::CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition, SkipBodyInfo *SkipBody) {\n  if (getLangOpts().GNUMode && Definition->isInlineSpecified() && Definition->getStorageClass() == SC_Extern)\n  else\n    Diag(FD->getLocation(), diag::err_redefinition) << FD;"},{t,15181,"/// This is invoked when we see \'struct foo\' or \'struct {\'.  In the\n/// former case, Name will be non-null.  In the later case, Name will be null.\n/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a\n/// reference/declaration/definition of a tag.\n///\n/// \\param IsTypeSpecifier \\c true if this is a type-specifier (or\n/// trailing-type-specifier) other than one in an alias-declaration.\n///\n/// \\param SkipBody If non-null, will be set to indicate if the caller should\n/// skip the definition of this tag and treat it as if it were a declaration.\nDeclResult Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attrs, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody) {\n  if (!Previous.empty()) {\n    if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {\n      // If this is a use of a previous tag, or if the tag is already declared\n      // in the same scope (so that the definition/declaration completes or\n      // rementions the tag), reuse the decl.\n      if (TUK == TUK_Reference || TUK == TUK_Friend || isDeclInScope(DirectPrevDecl, SearchDC, S, SS.isNotEmpty() || isMemberSpecialization)) {\n        if (!Invalid) {\n          // Diagnose attempts to redefine a tag.\n          if (TUK == TUK_Definition) {\n            if (NamedDecl *Def = PrevTagDecl->getDefinition()) {\n              if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {\n              } else if (!IsExplicitSpecializationAfterInstantiation) {\n                // A redeclaration in function prototype scope in C isn\'t\n                // visible elsewhere, so merely issue a warning.\n                if (!getLangOpts().CPlusPlus && S->containedInPrototypeScope())\n                else\n                  Diag(NameLoc, diag::err_redefinition) << Name;"},{t,17057,"Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val) {\n  if (PrevDecl) {\n    if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {\n      if (isa<EnumConstantDecl>(PrevDecl))\n      else\n        Diag(IdLoc, diag::err_redefinition) << Id;"},{y,793,"NamedDecl *Sema::ActOnDecompositionDeclarator(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParamLists) {\n  // Build the BindingDecls.\n  for (auto &B : D.getDecompositionDeclarator().bindings()) {\n    if (!Previous.empty()) {\n      Diag(B.NameLoc, diag::err_redefinition) << B.Name;"},{y,11138,"/// Checks that the given using declaration is not an invalid\n/// redeclaration.  Note that this is checking only for the using decl\n/// itself, not for any ill-formedness among the UsingShadowDecls.\nbool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Prev) {\n  // C++03 [namespace.udecl]p8:\n  // C++0x [namespace.udecl]p10:\n  //  A using-declaration is a declaration and can therefore be used\n  //  repeatedly where (and only where) multiple declarations are\n  //  allowed.\n  //\n  // That\'s in non-member contexts.\n  if (!CurContext->getRedeclContext()->isRecord()) {\n    // A dependent qualifier outside a class can only ever resolve to an\n    // enumeration type. Therefore it conflicts with any other non-type\n    // declaration in the same scope.\n    // FIXME: How should we check for dependent type-type conflicts at block\n    // scope?\n    if (Qual->isDependent() && !HasTypenameKeyword) {\n      for (auto *D : Prev) {\n        if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {\n          Diag(NameLoc, OldCouldBeEnumerator ? diag::err_redefinition : diag::err_redefinition_different_kind) << Prev.getLookupName();"},{y,11550,"Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident) {\n  if (PrevR.isSingleResult()) {\n    if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {\n    } else if (isVisible(PrevDecl)) {\n      unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl()) ? diag::err_redefinition : diag::err_redefinition_different_kind;"},{y,14293,"/// ActOnExceptionDeclarator - Parsed the exception-declarator in a C++ catch\n/// handler.\nDecl *Sema::ActOnExceptionDeclarator(Scope *S, Declarator &D) {\n  if (NamedDecl *PrevDecl = LookupSingleName(S, II, D.getIdentifierLoc(), LookupOrdinaryName, ForVisibleRedeclaration)) {\n    if (isDeclInScope(PrevDecl, CurContext, S)) {\n      Diag(D.getIdentifierLoc(), diag::err_redefinition) << D.getIdentifier();"},{p,4838,"ExprResult Sema::ActOnOMPIteratorExpr(Scope *S, SourceLocation IteratorKwLoc, SourceLocation LLoc, SourceLocation RLoc, ArrayRef<OMPIteratorData> Data) {\n  for (const OMPIteratorData &D : Data) {\n    if (S) {\n      if (!Previous.empty()) {\n        Diag(D.DeclIdentLoc, diag::err_redefinition) << VD->getDeclName();"},{q,1702,"DeclResult Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {\n  if (PrevClassTemplate) {\n    // Check for redefinition of this class template.\n    if (TUK == TUK_Definition) {\n      if (TagDecl *Def = PrevRecordDecl->getDefinition()) {\n        if (SkipBody && !hasVisibleDefinition(Def, &Hidden)) {\n        } else {\n          Diag(NameLoc, diag::err_redefinition) << Name;"},{q,7294,"DeclResult Sema::ActOnClassTemplateSpecialization(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, SourceLocation ModulePrivateLoc, CXXScopeSpec &SS, TemplateIdAnnotation &TemplateId, const ParsedAttributesView &Attr, MultiTemplateParamsArg TemplateParameterLists, SkipBodyInfo *SkipBody) {\n  // Check that this isn\'t a redefinition of this specialization.\n  if (TUK == TUK_Definition) {\n    if (Def && SkipBody && !hasVisibleDefinition(Def, &Hidden)) {\n    } else if (Def) {\n      Diag(TemplateNameLoc, diag::err_redefinition) << Specialization << Range;"},{q,7446,"void Sema::CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope) {\n  if (hasReachableDefinition(OldConcept) && IsRedefinitionInModule(NewDecl, OldConcept)) {\n    Diag(NewDecl->getLocation(), diag::err_redefinition) << NewDecl->getDeclName();"},{"clang/lib/Sema/SemaTemplateInstantiateDecl.cpp",3180,"Decl *TemplateDeclInstantiator::VisitClassTemplateSpecializationDecl(ClassTemplateSpecializationDecl *D) {\n  // If PrevDecl was a definition and D is also a definition, diagnose.\n  // This happens in cases like:\n  //\n  //  template<typename T, typename U>\n  //  struct Outer {\n  //    template<typename X> struct Inner;\n  //    template<> struct Inner<T> {};\n  //    template<> struct Inner<U> {};\n  //  };\n  //\n  //  Outer<int, int> outer; // error: the explicit specializations of Inner\n  //                          // have the same signature.\n  if (PrevDecl && PrevDecl->getDefinition() && D->isThisDeclarationADefinition()) {\n    SemaRef.Diag(D->getLocation(), diag::err_redefinition) << PrevDecl;"}}

[k]={{q,7440,"void Sema::CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope) {\n  if (!IsSame) {\n    Diag(NewDecl->getLocation(), diag::err_redefinition_different_concept) << NewDecl->getDeclName();"}}

[k]={{t,2362,"/// MergeTypedefNameDecl - We just parsed a typedef \'New\' which has the\n/// same name and scope as a previous declaration \'Old\'.  Figure out\n/// how to resolve this situation, merging decls or emitting\n/// diagnostics as appropriate. If there was an error, set New to be invalid.\n///\nvoid Sema::MergeTypedefNameDecl(Scope *S, TypedefNameDecl *New, LookupResult &OldDecls) {\n  if (!Old) {\n    Diag(New->getLocation(), diag::err_redefinition_different_kind) << New->getDeclName();"},{t,3291,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  if (!Old) {\n    if (UsingShadowDecl *Shadow = dyn_cast<UsingShadowDecl>(OldD)) {\n    } else {\n      Diag(New->getLocation(), diag::err_redefinition_different_kind) << New->getDeclName();"},{t,4080,"/// MergeVarDecl - We just parsed a variable \'New\' which has the same name\n/// and scope as a previous declaration \'Old\'.  Figure out how to resolve this\n/// situation, merging decls or emitting diagnostics as appropriate.\n///\n/// Tentative definition rules (C99 6.9.2p2) are checked by\n/// FinalizeDeclaratorGroup. Unfortunately, we can\'t analyze tentative\n/// definitions here, since the initializer hasn\'t been attached.\n///\nvoid Sema::MergeVarDecl(VarDecl *New, LookupResult &Previous) {\n  if (!Old) {\n    Diag(New->getLocation(), diag::err_redefinition_different_kind) << New->getDeclName();"},{t,15267,"/// This is invoked when we see \'struct foo\' or \'struct {\'.  In the\n/// former case, Name will be non-null.  In the later case, Name will be null.\n/// TagSpec indicates what kind of tag this is. TUK indicates whether this is a\n/// reference/declaration/definition of a tag.\n///\n/// \\param IsTypeSpecifier \\c true if this is a type-specifier (or\n/// trailing-type-specifier) other than one in an alias-declaration.\n///\n/// \\param SkipBody If non-null, will be set to indicate if the caller should\n/// skip the definition of this tag and treat it as if it were a declaration.\nDeclResult Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attrs, AccessSpecifier AS, SourceLocation ModulePrivateLoc, MultiTemplateParamsArg TemplateParameterLists, bool &OwnedDecl, bool &IsDependent, SourceLocation ScopedEnumKWLoc, bool ScopedEnumUsesClassTag, TypeResult UnderlyingType, bool IsTypeSpecifier, bool IsTemplateParamOrArg, OffsetOfKind OOK, SkipBodyInfo *SkipBody) {\n  if (!Previous.empty()) {\n    if (TagDecl *PrevTagDecl = dyn_cast<TagDecl>(PrevDecl)) {\n    } else {\n      // Use a better diagnostic if an elaborated-type-specifier\n      // found the wrong kind of type on the first\n      // (non-redeclaration) lookup.\n      if ((TUK == TUK_Reference || TUK == TUK_Friend) && !Previous.isForRedeclaration()) {\n      } else if (!isDeclInScope(DirectPrevDecl, SearchDC, S, SS.isNotEmpty() || isMemberSpecialization)) {\n      } else if (TUK == TUK_Reference || TUK == TUK_Friend) {\n      } else if (TypedefNameDecl *TND = dyn_cast<TypedefNameDecl>(PrevDecl)) {\n      } else {\n        Diag(NameLoc, diag::err_redefinition_different_kind) << Name;"},{y,9820,"/// ActOnStartNamespaceDef - This is called at the start of a namespace\n/// definition.\nDecl *Sema::ActOnStartNamespaceDef(Scope *NamespcScope, SourceLocation InlineLoc, SourceLocation NamespaceLoc, SourceLocation IdentLoc, IdentifierInfo *II, SourceLocation LBrace, const ParsedAttributesView &AttrList, UsingDirectiveDecl *&UD, bool IsNested) {\n  if (II) {\n    if (PrevNS) {\n    } else if (PrevDecl) {\n      Diag(Loc, diag::err_redefinition_different_kind) << II;"},{y,11138,"/// Checks that the given using declaration is not an invalid\n/// redeclaration.  Note that this is checking only for the using decl\n/// itself, not for any ill-formedness among the UsingShadowDecls.\nbool Sema::CheckUsingDeclRedeclaration(SourceLocation UsingLoc, bool HasTypenameKeyword, const CXXScopeSpec &SS, SourceLocation NameLoc, const LookupResult &Prev) {\n  // C++03 [namespace.udecl]p8:\n  // C++0x [namespace.udecl]p10:\n  //  A using-declaration is a declaration and can therefore be used\n  //  repeatedly where (and only where) multiple declarations are\n  //  allowed.\n  //\n  // That\'s in non-member contexts.\n  if (!CurContext->getRedeclContext()->isRecord()) {\n    // A dependent qualifier outside a class can only ever resolve to an\n    // enumeration type. Therefore it conflicts with any other non-type\n    // declaration in the same scope.\n    // FIXME: How should we check for dependent type-type conflicts at block\n    // scope?\n    if (Qual->isDependent() && !HasTypenameKeyword) {\n      for (auto *D : Prev) {\n        if (!isa<TypeDecl>(D) && !isa<UsingDecl>(D) && !isa<UsingPackDecl>(D)) {\n          Diag(NameLoc, OldCouldBeEnumerator ? diag::err_redefinition : diag::err_redefinition_different_kind) << Prev.getLookupName();"},{y,11443,"Decl *Sema::ActOnAliasDeclaration(Scope *S, AccessSpecifier AS, MultiTemplateParamsArg TemplateParamLists, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec) {\n  if (TemplateParamLists.size()) {\n    if (!Previous.empty()) {\n      if (!OldDecl && !Invalid) {\n        Diag(UsingLoc, diag::err_redefinition_different_kind) << Name.Identifier;"},{y,11550,"Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident) {\n  if (PrevR.isSingleResult()) {\n    if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {\n    } else if (isVisible(PrevDecl)) {\n      unsigned DiagID = isa<NamespaceDecl>(PrevDecl->getUnderlyingDecl()) ? diag::err_redefinition : diag::err_redefinition_different_kind;"},{Y,514,"void Sema::ActOnSuperClassOfClassInterface(Scope *S, SourceLocation AtInterfaceLoc, ObjCInterfaceDecl *IDecl, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange) {\n  if (declaresSameEntity(PrevDecl, IDecl)) {\n  } else {\n    if (PrevDecl && !SuperClassDecl) {\n      // This handles the following case:\n      //\n      // typedef int SuperClass;\n      // @interface MyClass : SuperClass {} @end\n      //\n      if (!SuperClassDecl) {\n        Diag(SuperLoc, diag::err_redefinition_different_kind) << SuperName;"},{Y,782,"ObjCInterfaceDecl *Sema::ActOnStartClassInterface(Scope *S, SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList, SkipBodyInfo *SkipBody) {\n  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {\n    Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;"},{Y,1601,"ObjCImplementationDecl *Sema::ActOnStartClassImplementation(SourceLocation AtClassImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperClassname, SourceLocation SuperClassLoc, const ParsedAttributesView &Attrs) {\n  if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {\n    Diag(ClassLoc, diag::err_redefinition_different_kind) << ClassName;"},{Y,1629,"ObjCImplementationDecl *Sema::ActOnStartClassImplementation(SourceLocation AtClassImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperClassname, SourceLocation SuperClassLoc, const ParsedAttributesView &Attrs) {\n  if (SuperClassname) {\n    if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {\n      Diag(SuperClassLoc, diag::err_redefinition_different_kind) << SuperClassname;"},{Y,2475,"Sema::DeclGroupPtrTy Sema::ActOnForwardClassDeclaration(SourceLocation AtClassLoc, IdentifierInfo **IdentList, SourceLocation *IdentLocs, ArrayRef<ObjCTypeParamList *> TypeParamLists, unsigned NumElts) {\n  for (unsigned i = 0; i != NumElts; ++i) {\n    if (PrevDecl && !isa<ObjCInterfaceDecl>(PrevDecl)) {\n      if (!TDD || !TDD->getUnderlyingType()->isObjCObjectType()) {\n        Diag(AtClassLoc, diag::err_redefinition_different_kind) << IdentList[i];"},{q,1716,"DeclResult Sema::CheckClassTemplate(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, CXXScopeSpec &SS, IdentifierInfo *Name, SourceLocation NameLoc, const ParsedAttributesView &Attr, TemplateParameterList *TemplateParams, AccessSpecifier AS, SourceLocation ModulePrivateLoc, SourceLocation FriendLoc, unsigned NumOuterTemplateParamLists, TemplateParameterList **OuterTemplateParamLists, SkipBodyInfo *SkipBody) {\n  if (PrevClassTemplate) {\n  } else if (PrevDecl) {\n    Diag(NameLoc, diag::err_redefinition_different_kind) << Name;"},{q,7432,"void Sema::CheckConceptRedefinition(ConceptDecl *NewDecl, LookupResult &Previous, bool &AddToScope) {\n  if (!OldConcept) {\n    Diag(NewDecl->getLocation(), diag::err_redefinition_different_kind) << NewDecl->getDeclName();"}}

[k]={{y,11545,"Decl *Sema::ActOnNamespaceAliasDef(Scope *S, SourceLocation NamespaceLoc, SourceLocation AliasLoc, IdentifierInfo *Alias, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident) {\n  if (PrevR.isSingleResult()) {\n    if (NamespaceAliasDecl *AD = dyn_cast<NamespaceAliasDecl>(PrevDecl)) {\n      // We already have an alias with the same name that points to the same\n      // namespace; check that it matches.\n      if (AD->getNamespace()->Equals(getNamespaceDecl(ND))) {\n      } else if (isVisible(PrevDecl)) {\n        Diag(AliasLoc, diag::err_redefinition_different_namespace_alias) << Alias;"}}

[k]={{t,3922,"static void diagnoseVarDeclTypeMismatch(Sema &S, VarDecl *New, VarDecl *Old) {\n  S.Diag(New->getLocation(), New->isThisDeclarationADefinition() ? diag::err_redefinition_different_type : diag::err_redeclaration_different_type) << New->getDeclName() << New->getType() << Old->getType();"}}

[k]={{t,2298,"bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {\n  if (OldType != NewType && !OldType->isDependentType() && !NewType->isDependentType() && !Context.hasSameType(OldType, NewType)) {\n    Diag(New->getLocation(), diag::err_redefinition_different_typedef) << Kind << NewType << OldType;"},{y,11463,"Decl *Sema::ActOnAliasDeclaration(Scope *S, AccessSpecifier AS, MultiTemplateParamsArg TemplateParamLists, SourceLocation UsingLoc, UnqualifiedId &Name, const ParsedAttributesView &AttrList, TypeResult Type, Decl *DeclFromDeclSpec) {\n  if (TemplateParamLists.size()) {\n    if (!Previous.empty()) {\n      if (!Invalid && OldDecl && !OldDecl->isInvalidDecl()) {\n        if (!Invalid && !Context.hasSameType(OldTD->getUnderlyingType(), NewTD->getUnderlyingType())) {\n          Diag(NewTD->getLocation(), diag::err_redefinition_different_typedef) << 2 << NewTD->getUnderlyingType() << OldTD->getUnderlyingType();"}}

[k]={{t,13234,"void Sema::CheckForFunctionRedefinition(FunctionDecl *FD, const FunctionDecl *EffectiveDefinition, SkipBodyInfo *SkipBody) {\n  if (getLangOpts().GNUMode && Definition->isInlineSpecified() && Definition->getStorageClass() == SC_Extern)\n    Diag(FD->getLocation(), diag::err_redefinition_extern_inline) << FD << getLangOpts().CPlusPlus;"}}

[k]={{t,17055,"Decl *Sema::ActOnEnumConstant(Scope *S, Decl *theEnumDecl, Decl *lastEnumConst, SourceLocation IdLoc, IdentifierInfo *Id, const ParsedAttributesView &Attrs, SourceLocation EqualLoc, Expr *Val) {\n  if (PrevDecl) {\n    if (!isa<TagDecl>(PrevDecl) && isDeclInScope(PrevDecl, CurContext, S)) {\n      if (isa<EnumConstantDecl>(PrevDecl))\n        Diag(IdLoc, diag::err_redefinition_of_enumerator) << Id;"}}

[k]={{K,505,"StmtResult Sema::ActOnLabelStmt(SourceLocation IdentLoc, LabelDecl *TheDecl, SourceLocation ColonLoc, Stmt *SubStmt) {\n  // If the label was multiply defined, reject it now.\n  if (TheDecl->getStmt()) {\n    Diag(IdentLoc, diag::err_redefinition_of_label) << TheDecl->getDeclName();"}}

[k]={{t,2289,"bool Sema::isIncompatibleTypedef(TypeDecl *Old, TypedefNameDecl *New) {\n  if (NewType->isVariablyModifiedType()) {\n    Diag(New->getLocation(), diag::err_redefinition_variably_modified_typedef) << Kind << NewType;"}}

[k]={{p,16685,"// Returns true if the capture by block was successful.\nstatic bool captureInBlock(BlockScopeInfo *BSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool Nested, Sema &S, bool Invalid) {\n  // Blocks are not allowed to capture arrays, excepting OpenCL.\n  // OpenCL v2.0 s1.12.5 (revision 40): arrays are captured by reference\n  // (decayed to pointers).\n  if (!Invalid && !S.getLangOpts().OpenCL && CaptureType->isArrayType()) {\n    if (BuildAndDiagnose) {\n      S.Diag(Loc, diag::err_ref_array_type);"}}

[k]={{"clang/lib/Sema/SemaCUDA.cpp",743,"bool Sema::CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee) {\n  SemaDiagnosticBuilder(DiagKind, Loc, diag::err_ref_bad_target, Caller, *this) << IdentifyCUDATarget(Callee) << /*function*/ 0 << Callee << IdentifyCUDATarget(Caller);"},{p,16502,"/// Directly mark a variable odr-used. Given a choice, prefer to use\n/// MarkVariableReferenced since it does additional checks and then\n/// calls MarkVarDeclODRUsed.\n/// If the variable must be captured:\n///  - if FunctionScopeIndexToStopAt is null, capture it in the CurContext\n///  - else capture it in the DeclContext that maps to the\n///    *FunctionScopeIndexToStopAt on the FunctionScopeInfo stack.\nstatic void MarkVarDeclODRUsed(ValueDecl *V, SourceLocation Loc, Sema &SemaRef, const unsigned *const FunctionScopeIndexToStopAt = nullptr) {\n  if (SemaRef.LangOpts.CUDA && Var->hasGlobalStorage()) {\n    if (VarTarget == Sema::CVT_Host && (UserTarget == Sema::CFT_Device || UserTarget == Sema::CFT_HostDevice || UserTarget == Sema::CFT_Global)) {\n      // Diagnose ODR-use of host global variables in device functions.\n      // Reference of device global variables in host functions is allowed\n      // through shadow variables therefore it is not diagnosed.\n      if (SemaRef.LangOpts.CUDAIsDevice) {\n        SemaRef.targetDiag(Loc, diag::err_ref_bad_target) << /*host*/ 2 << /*variable*/ 1 << Var << UserTarget;"}}

[k]={{"clang/lib/Sema/SemaCUDA.cpp",574,"void Sema::checkAllowedCUDAInitializer(VarDecl *VD) {\n  if (IsDeviceOrConstantVar || IsSharedVar) {\n  } else {\n    if (InitFn) {\n      if (InitFnTarget != CFT_Host && InitFnTarget != CFT_HostDevice) {\n        Diag(VD->getLocation(), diag::err_ref_bad_target_global_initializer) << InitFnTarget << InitFn;"}}

[k]={{p,16637,"// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture\n// certain types of variables (unnamed, variably modified types etc.)\n// so check for eligibility.\nstatic bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S) {\n  // Prohibit structs with flexible array members too.\n  // We cannot capture what is in the tail end of the struct.\n  if (const RecordType *VTTy = Var->getType()->getAs<RecordType>()) {\n    if (VTTy->getDecl()->hasFlexibleArrayMember()) {\n      if (Diagnose) {\n        if (IsBlock)\n          S.Diag(Loc, diag::err_ref_flexarray_type);"}}

[k]={{D,8173,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_UserConversionOverloadFailed:\n    case OR_Ambiguous:\n      FailedCandidateSet.NoteCandidates(PartialDiagnosticAt(Kind.getLocation(), Failure == FK_UserConversionOverloadFailed ? (S.PDiag(diag::err_typecheck_ambiguous_condition) << OnlyArg->getType() << DestType << Args[0]->getSourceRange()) : (S.PDiag(diag::err_ref_init_ambiguous) << DestType << OnlyArg->getType() << Args[0]->getSourceRange())), S, OCD_AmbiguousCandidates, Args);"}}

[k]={{p,2907,"/// Complete semantic analysis for a reference to the given declaration.\nExprResult Sema::BuildDeclarationNameExpr(const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, NamedDecl *D, NamedDecl *FoundD, const TemplateArgumentListInfo *TemplateArgs, bool AcceptInvalidDecl) {\n  // Make sure that we\'re referring to a value.\n  if (!isa<ValueDecl, UnresolvedUsingIfExistsDecl>(D)) {\n    Diag(Loc, diag::err_ref_non_value) << D << SS.getRange();"}}

[k]={{y,7421,"bool Sema::CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *FD, DefaultedComparisonKind DCK) {\n  if (IsMethod) {\n    if (MD->getRefQualifier() == RQ_RValue) {\n      Diag(MD->getLocation(), diag::err_ref_qualifier_comparison_operator);"}}

[k]={{y,9224,"/// CheckConstructorDeclarator - Called by ActOnDeclarator to check\n/// the well-formedness of the constructor declarator @p D with type @p\n/// R. If there are any errors in the declarator, this routine will\n/// emit diagnostics and set the invalid bit to true.  In any case, the type\n/// will be updated to reflect a well-formed type for the constructor and\n/// returned.\nQualType Sema::CheckConstructorDeclarator(Declarator &D, QualType R, StorageClass &SC) {\n  if (FTI.hasRefQualifier()) {\n    Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_constructor) << FTI.RefQualifierIsLValueRef << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());"}}

[k]={{y,9376,"/// CheckDestructorDeclarator - Called by ActOnDeclarator to check\n/// the well-formednes of the destructor declarator @p D with type @p\n/// R. If there are any errors in the declarator, this routine will\n/// emit diagnostics and set the declarator to invalid.  Even if this happens,\n/// will be updated to reflect a well-formed type for the destructor and\n/// returned.\nQualType Sema::CheckDestructorDeclarator(Declarator &D, QualType R, StorageClass &SC) {\n  if (FTI.hasRefQualifier()) {\n    Diag(FTI.getRefQualifierLoc(), diag::err_ref_qualifier_destructor) << FTI.RefQualifierIsLValueRef << FixItHint::CreateRemoval(FTI.getRefQualifierLoc());"}}

[k]={{ab,1189,"bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs, bool ConsiderRequiresClauses) {\n  if (OldMethod && NewMethod && !OldMethod->isStatic() && !NewMethod->isStatic()) {\n    if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {\n      if (!UseMemberUsingDeclRules && (OldMethod->getRefQualifier() == RQ_None || NewMethod->getRefQualifier() == RQ_None)) {\n        Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload) << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();"}}

[k]={{p,16626,"// Certain capturing entities (lambdas, blocks etc.) are not allowed to capture\n// certain types of variables (unnamed, variably modified types etc.)\n// so check for eligibility.\nstatic bool isVariableCapturable(CapturingScopeInfo *CSI, ValueDecl *Var, SourceLocation Loc, const bool Diagnose, Sema &S) {\n  // Prohibit variably-modified types in blocks; they\'re difficult to deal with.\n  if (Var->getType()->isVariablyModifiedType() && IsBlock) {\n    if (Diagnose) {\n      S.Diag(Loc, diag::err_ref_vm_type);"}}

[k]={{"clang/lib/Tooling/Refactoring/Extract/Extract.cpp",74,"Expected<ExtractFunction> ExtractFunction::initiate(RefactoringRuleContext &Context, CodeRangeASTSelection Code, std::optional<std::string> DeclName) {\n  // We would like to extract code out of functions/methods/blocks.\n  // Prohibit extraction from things like global variable / field\n  // initializers and other top-level expressions.\n  if (!Code.isInFunctionLikeBodyOfCode())\n    return Context.createDiagnosticError(diag::err_refactor_code_outside_of_function);"}}

[k]={{"clang/lib/Tooling/Refactoring/Extract/Extract.cpp",84,"Expected<ExtractFunction> ExtractFunction::initiate(RefactoringRuleContext &Context, CodeRangeASTSelection Code, std::optional<std::string> DeclName) {\n  if (Code.size() == 1) {\n    // Property setters can\'t be extracted.\n    if (const auto *PRE = dyn_cast<ObjCPropertyRefExpr>(Code[0])) {\n      if (!PRE->isMessagingGetter())\n        return Context.createDiagnosticError(diag::err_refactor_extract_prohibited_expression);"}}

[k]={{"clang/lib/Tooling/Refactoring/Extract/Extract.cpp",79,"Expected<ExtractFunction> ExtractFunction::initiate(RefactoringRuleContext &Context, CodeRangeASTSelection Code, std::optional<std::string> DeclName) {\n  if (Code.size() == 1) {\n    // Avoid extraction of simple literals and references.\n    if (isSimpleExpression(dyn_cast<Expr>(Code[0])))\n      return Context.createDiagnosticError(diag::err_refactor_extract_simple_expression);"}}

[k]={{"clang/unittests/Tooling/RefactoringActionRulesTest.cpp",117,"TEST_F(RefactoringActionRulesTest, MyFirstRefactoringRule) {\n  // When one of the requirements is not satisfied, invoke should return a\n  // valid error.\n  {\n    EXPECT_EQ(DiagID, diag::err_refactor_no_selection);"}}

[k]={{"clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp",24,"Expected<SelectedASTNode> ASTSelectionRequirement::evaluate(RefactoringRuleContext &Context) const {\n  if (!Selection)\n    return Context.createDiagnosticError(Range->getBegin(), diag::err_refactor_selection_invalid_ast);"},{"clang/lib/Tooling/Refactoring/ASTSelectionRequirements.cpp",36,"Expected<CodeRangeASTSelection> CodeRangeASTSelectionRequirement::evaluate(RefactoringRuleContext &Context) const {\n  if (!CodeRange)\n    return Context.createDiagnosticError(Context.getSelectionRange().getBegin(), diag::err_refactor_selection_invalid_ast);"}}

[k]={{"clang/lib/Tooling/Refactoring/Rename/RenamingAction.cpp",65,"Expected<RenameOccurrences> RenameOccurrences::initiate(RefactoringRuleContext &Context, SourceRange SelectionRange, std::string NewName) {\n  if (!ND)\n    return Context.createDiagnosticError(SelectionRange.getBegin(), diag::err_refactor_selection_no_symbol);"}}

[k]={{D,8243,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ReferenceInitDropsQualifiers: {\n    if (!NonRefType.getQualifiers().isAddressSpaceSupersetOf(SourceType.getQualifiers()))\n      S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals) << NonRefType << SourceType << 1 /*addr space*/"},{D,8246,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ReferenceInitDropsQualifiers: {\n    if (!NonRefType.getQualifiers().isAddressSpaceSupersetOf(SourceType.getQualifiers()))\n    else if (DroppedQualifiers.hasQualifiers())\n      S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals) << NonRefType << SourceType << 0 /*cv quals*/"},{D,8251,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ReferenceInitDropsQualifiers: {\n    if (!NonRefType.getQualifiers().isAddressSpaceSupersetOf(SourceType.getQualifiers()))\n    else if (DroppedQualifiers.hasQualifiers())\n    else\n      S.Diag(Kind.getLocation(), diag::err_reference_bind_drops_quals) << NonRefType << SourceType << 2 /*incompatible quals*/"}}

[k]={{D,8257,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ReferenceInitFailed:\n    S.Diag(Kind.getLocation(), diag::err_reference_bind_failed) << DestType.getNonReferenceType() << DestType.getNonReferenceType()->isIncompleteType() << OnlyArg->isLValue() << OnlyArg->getType() << Args[0]->getSourceRange();"}}

[k]={{D,8298,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ReferenceBindingToInitList:\n    S.Diag(Kind.getLocation(), diag::err_reference_bind_init_list) << DestType.getNonReferenceType() << Args[0]->getSourceRange();"}}

[k]={{D,8234,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_ReferenceAddrspaceMismatchTemporary:\n    S.Diag(Kind.getLocation(), diag::err_reference_bind_temporary_addrspace) << DestType << Args[0]->getSourceRange();"}}

[k]={{D,8215,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NonConstLValueReferenceBindingToBitfield: {\n    S.Diag(Kind.getLocation(), diag::err_reference_bind_to_bitfield) << DestType.isVolatileQualified() << (BitField ? BitField->getDeclName() : DeclarationName()) << (BitField != nullptr) << Args[0]->getSourceRange();"}}

[k]={{D,8226,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NonConstLValueReferenceBindingToMatrixElement:\n    S.Diag(Kind.getLocation(), diag::err_reference_bind_to_matrix_element) << DestType.isVolatileQualified() << Args[0]->getSourceRange();"}}

[k]={{D,8222,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NonConstLValueReferenceBindingToVectorElement:\n    S.Diag(Kind.getLocation(), diag::err_reference_bind_to_vector_element) << DestType.isVolatileQualified() << Args[0]->getSourceRange();"}}

[k]={{yb,962,"void Sema::ActOnLambdaExpressionAfterIntroducer(LambdaIntroducer &Intro, Scope *CurrentScope) {\n  for (auto C = Intro.Captures.begin(), E = Intro.Captures.end(); C != E; PrevCaptureLoc = C->Loc, ++C) {\n    if (C->Init.isUsable()) {\n    } else {\n      // C++11 [expr.prim.lambda]p8:\n      //  If a lambda-capture includes a capture-default that is &, the\n      //  identifiers in the lambda-capture shall not be preceded by &.\n      //  If a lambda-capture includes a capture-default that is =, [...]\n      //  each identifier it contains shall be preceded by &.\n      if (C->Kind == LCK_ByRef && Intro.Default == LCD_ByRef) {\n        Diag(C->Loc, diag::err_reference_capture_with_reference_default) << FixItHint::CreateRemoval(SourceRange(getLocForEndOfToken(PrevCaptureLoc), C->Loc));"}}

[k]={{D,8116,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_TooManyInitsForReference:\n    // FIXME: Customize for the initialized entity?\n    if (Args.empty()) {\n    } else // FIXME: diagnostic below could be better!\n      S.Diag(Kind.getLocation(), diag::err_reference_has_multiple_inits) << SourceRange(Args.front()->getBeginLoc(), Args.back()->getEndLoc());"}}