Module:ClangDiags/DiagsLongData5: Difference between revisions

[j]={{E,3479,"TypeResult Sema::ActOnTemplateIdType(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, IdentifierInfo *TemplateII, SourceLocation TemplateIILoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, bool IsCtorOrDtorName, bool IsClassName, ImplicitTypenameContext AllowImplicitTypename) {\n  if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {\n    // C++ [temp.res]p3:\n    //  A qualified-id that refers to a type and in which the\n    //  nested-name-specifier depends on a template-parameter (14.6.2)\n    //  shall be prefixed by the keyword typename to indicate that the\n    //  qualified-id denotes a type, forming an\n    //  elaborated-type-specifier (7.1.5.3).\n    if (!LookupCtx && isDependentScopeSpecifier(SS)) {\n      // C++2a relaxes some of those restrictions in [temp.res]p5.\n      if (AllowImplicitTypename == ImplicitTypenameContext::Yes) {\n      } else\n        Diag(SS.getBeginLoc(), diag::err_typename_missing_template) << SS.getScopeRep() << TemplateII->getName();"}}

[j]={{w,719,"void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName) {\n  if (!SS || (!SS->isSet() && !SS->isInvalid()))\n  else if (DeclContext *DC = computeDeclContext(*SS, false))\n    Diag(IILoc, IsTemplateName ? diag::err_no_member_template : diag::err_typename_nested_not_found) << II << DC << SS->getRange();"},{E,9090,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::NotFound: {\n    DiagID = Ctx ? diag::err_typename_nested_not_found : diag::err_unknown_typename;"}}

[j]={{Jb,9562,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_SubstitutionFailure: {\n    if (PDiag && PDiag->second.getDiagID() == diag::err_typename_nested_not_found_enable_if) {"},{E,3312,"QualType Sema::CheckTemplateIdType(TemplateName Name, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs) {\n  if (TypeAliasTemplateDecl *AliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Template)) {\n    if (CanonType.isNull()) {\n      // If this was enable_if and we failed to find the nested type\n      // within enable_if in a SFINAE context, dig out the specific\n      // enable_if condition that failed and present that instead.\n      if (isEnableIfAliasTemplate(AliasTemplate)) {\n        if (auto DeductionInfo = isSFINAEContext()) {\n          if (*DeductionInfo && (*DeductionInfo)->hasSFINAEDiagnostic() && (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() == diag::err_typename_nested_not_found_enable_if && TemplateArgs[0].getArgument().getKind() == TemplateArgument::Expression) {"},{E,9086,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::NotFound: {\n    if (Ctx && isEnableIf(QualifierLoc, II, CondRange, Cond)) {\n      Diag(CondRange.getBegin(), diag::err_typename_nested_not_found_enable_if) << Ctx << CondRange;"}}

[j]={{Jb,9570,"/// Diagnose a failed template-argument deduction.\nstatic void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated, DeductionFailureInfo &DeductionFailure, unsigned NumArgs, bool TakingCandidateAddress) {\n  case Sema::TDK_SubstitutionFailure: {\n    if (PDiag && PDiag->second.getDiagID() == diag::err_typename_nested_not_found_requirement) {"},{E,3323,"QualType Sema::CheckTemplateIdType(TemplateName Name, SourceLocation TemplateLoc, TemplateArgumentListInfo &TemplateArgs) {\n  if (TypeAliasTemplateDecl *AliasTemplate = dyn_cast<TypeAliasTemplateDecl>(Template)) {\n    if (CanonType.isNull()) {\n      // If this was enable_if and we failed to find the nested type\n      // within enable_if in a SFINAE context, dig out the specific\n      // enable_if condition that failed and present that instead.\n      if (isEnableIfAliasTemplate(AliasTemplate)) {\n        if (auto DeductionInfo = isSFINAEContext()) {\n          if (*DeductionInfo && (*DeductionInfo)->hasSFINAEDiagnostic() && (*DeductionInfo)->peekSFINAEDiagnostic().second.getDiagID() == diag::err_typename_nested_not_found_enable_if && TemplateArgs[0].getArgument().getKind() == TemplateArgument::Expression) {\n            (*DeductionInfo)->addSFINAEDiagnostic(OldDiag.first, PDiag(diag::err_typename_nested_not_found_requirement) << FailedDescription << FailedCond->getSourceRange());"},{E,9082,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::NotFound: {\n    if (Ctx && isEnableIf(QualifierLoc, II, CondRange, Cond)) {\n      // If we have a condition, narrow it down to the specific failed\n      // condition.\n      if (Cond) {\n        Diag(FailedCond->getExprLoc(), diag::err_typename_nested_not_found_requirement) << FailedDescription << FailedCond->getSourceRange();"}}

[j]={{E,9158,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::Found:\n    DiagID = Ctx ? diag::err_typename_nested_not_type : diag::err_typename_not_type;"},{E,9163,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::FoundOverloaded:\n    DiagID = Ctx ? diag::err_typename_nested_not_type : diag::err_typename_not_type;"}}

[j]={{E,9158,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::Found:\n    DiagID = Ctx ? diag::err_typename_nested_not_type : diag::err_typename_not_type;"},{E,9163,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::FoundOverloaded:\n    DiagID = Ctx ? diag::err_typename_nested_not_type : diag::err_typename_not_type;"}}

[j]={{wb,1834,"/// TryAnnotateTypeOrScopeToken - If the current token position is on a\n/// typename (possibly qualified in C++) or a C++ scope specifier not followed\n/// by a typename, TryAnnotateTypeOrScopeToken will replace one or more tokens\n/// with a single annotation token representing the typename or C++ scope\n/// respectively.\n/// This simplifies handling of C++ scope specifiers and allows efficient\n/// backtracking without the need to re-parse and resolve nested-names and\n/// typenames.\n/// It will mainly be called when we expect to treat identifiers as typenames\n/// (if they are typenames). For example, in C we do not expect identifiers\n/// inside expressions to be treated as typenames so it will not be called\n/// for expressions in C.\n/// The benefit for C/ObjC is that a typename will be annotated and\n/// Actions.getTypeName will not be needed to be called again (e.g. getTypeName\n/// will not be called twice, once to check whether we have a declaration\n/// specifier, and another one to get the actual type inside\n/// ParseDeclarationSpecifiers).\n///\n/// This returns true if an error occurred.\n///\n/// Note that this routine emits an error if you call it with ::new or ::delete\n/// as the current tokens, so only call it in contexts where these are invalid.\nbool Parser::TryAnnotateTypeOrScopeToken(ImplicitTypenameContext AllowImplicitTypename) {\n  if (Tok.is(tok::kw_typename)) {\n    if (Tok.is(tok::identifier)) {\n    } else if (Tok.is(tok::annot_template_id)) {\n      if (!TemplateId->mightBeType()) {\n        Diag(Tok, diag::err_typename_refers_to_non_type_template) << Tok.getAnnotationRange();"}}

[j]={{E,9098,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::FoundUnresolvedValue: {\n    Diag(IILoc, diag::err_typename_refers_to_using_value_decl) << Name << Ctx << FullRange;"}}

[j]={{F,2410,"/// ParseSpecifierQualifierList\n///        specifier-qualifier-list:\n///          type-specifier specifier-qualifier-list[opt]\n///          type-qualifier specifier-qualifier-list[opt]\n/// [GNU]    attributes    specifier-qualifier-list[opt]\n///\nvoid Parser::ParseSpecifierQualifierList(DeclSpec &DS, ImplicitTypenameContext AllowImplicitTypename, AccessSpecifier AS, DeclSpecContext DSC) {\n  if (isTypeSpecifier(DSC) && !DS.hasTypeSpecifier()) {\n  } else if (Specs == DeclSpec::PQ_None && !DS.hasAttributes()) {\n    Diag(Tok, diag::err_typename_requires_specqual);"}}

[j]={{Z,3239,"uint32_t Lexer::tryReadUCN(const char *&StartPtr, const char *SlashLoc, Token *Result) {\n  // C++11 [lex.charset]p2: If the hexadecimal value for a\n  //  universal-character-name corresponds to a surrogate code point (in the\n  //  range 0xD800-0xDFFF, inclusive), the program is ill-formed. Additionally,\n  //  if the hexadecimal value for a universal-character-name outside the\n  //  c-char-sequence, s-char-sequence, or r-char-sequence of a character or\n  //  string literal corresponds to a control character (in either of the\n  //  ranges 0x00-0x1F or 0x7F-0x9F, both inclusive) or to a character in the\n  //  basic source character set, the program is ill-formed.\n  if (CodePoint < 0xA0) {\n    // We don\'t use isLexingRawMode() here because we need to warn about bad\n    // UCNs even when skipping preprocessing tokens in a #if block.\n    if (Result && PP) {\n      if (CodePoint < 0x20 || CodePoint >= 0x7F)\n        Diag(BufferPtr, diag::err_ucn_control_character);"},{cb,575,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  // C2x and C++11 allow UCNs that refer to control characters\n  // and basic source characters inside character and string literals\n  if (UcnVal < 0xa0 &&\n    if (Diags) {\n      if (UcnVal >= 0x20 && UcnVal < 0x7f)\n      else\n        Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, IsError ? diag::err_ucn_control_character : Features.CPlusPlus ? diag::warn_cxx98_compat_literal_ucn_control_character : diag::warn_c2x_compat_literal_ucn_control_character);"}}

[j]={{Z,3242,"uint32_t Lexer::tryReadUCN(const char *&StartPtr, const char *SlashLoc, Token *Result) {\n  // C++11 [lex.charset]p2: If the hexadecimal value for a\n  //  universal-character-name corresponds to a surrogate code point (in the\n  //  range 0xD800-0xDFFF, inclusive), the program is ill-formed. Additionally,\n  //  if the hexadecimal value for a universal-character-name outside the\n  //  c-char-sequence, s-char-sequence, or r-char-sequence of a character or\n  //  string literal corresponds to a control character (in either of the\n  //  ranges 0x00-0x1F or 0x7F-0x9F, both inclusive) or to a character in the\n  //  basic source character set, the program is ill-formed.\n  if (CodePoint < 0xA0) {\n    // We don\'t use isLexingRawMode() here because we need to warn about bad\n    // UCNs even when skipping preprocessing tokens in a #if block.\n    if (Result && PP) {\n      if (CodePoint < 0x20 || CodePoint >= 0x7F)\n      else {\n        Diag(BufferPtr, diag::err_ucn_escape_basic_scs) << StringRef(&C, 1);"},{cb,573,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  // C2x and C++11 allow UCNs that refer to control characters\n  // and basic source characters inside character and string literals\n  if (UcnVal < 0xa0 &&\n    if (Diags) {\n      if (UcnVal >= 0x20 && UcnVal < 0x7f)\n        Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, IsError ? diag::err_ucn_escape_basic_scs : Features.CPlusPlus ? diag::warn_cxx98_compat_literal_ucn_escape_basic_scs : diag::warn_c2x_compat_literal_ucn_escape_basic_scs) << StringRef(&BasicSCSChar, 1);"}}

[j]={{cb,463,"static bool ProcessNumericUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, bool &Delimited, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  // If we didn\'t consume the proper number of digits, there is a problem.\n  if (Count == 0 || (!Delimited && Count != UcnLen)) {\n    if (Diags)\n      Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, Delimited ? diag::err_delimited_escape_empty : diag::err_ucn_escape_incomplete);"},{cb,521,"static bool ProcessNamedUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features) {\n  if (Incomplete || Empty) {\n    if (Diags) {\n      Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, Incomplete ? diag::err_ucn_escape_incomplete : diag::err_delimited_escape_empty) << StringRef(&UcnBegin[1], 1);"}}

[j]={{Z,3255,"uint32_t Lexer::tryReadUCN(const char *&StartPtr, const char *SlashLoc, Token *Result) {\n  // C++11 [lex.charset]p2: If the hexadecimal value for a\n  //  universal-character-name corresponds to a surrogate code point (in the\n  //  range 0xD800-0xDFFF, inclusive), the program is ill-formed. Additionally,\n  //  if the hexadecimal value for a universal-character-name outside the\n  //  c-char-sequence, s-char-sequence, or r-char-sequence of a character or\n  //  string literal corresponds to a control character (in either of the\n  //  ranges 0x00-0x1F or 0x7F-0x9F, both inclusive) or to a character in the\n  //  basic source character set, the program is ill-formed.\n  if (CodePoint < 0xA0) {\n  } else if (CodePoint >= 0xD800 && CodePoint <= 0xDFFF) {\n    // C++03 allows UCNs representing surrogate characters. C99 and C++11 don\'t.\n    // We don\'t use isLexingRawMode() here because we need to diagnose bad\n    // UCNs even when skipping preprocessing tokens in a #if block.\n    if (Result && PP) {\n      if (LangOpts.CPlusPlus && !LangOpts.CPlusPlus11)\n      else\n        Diag(BufferPtr, diag::err_ucn_escape_invalid);"},{cb,560,"/// ProcessUCNEscape - Read the Universal Character Name, check constraints and\n/// return the UTF32.\nstatic bool ProcessUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, uint32_t &UcnVal, unsigned short &UcnLen, FullSourceLoc Loc, DiagnosticsEngine *Diags, const LangOptions &Features, bool in_char_string_literal = false) {\n  // Check UCN constraints (C99 6.4.3p2) [C++11 lex.charset p2]\n  if ((0xD800 <= UcnVal && UcnVal <= 0xDFFF) || // surrogate codepoints\n    if (Diags)\n      Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, diag::err_ucn_escape_invalid);"}}

[j]={{"clang/lib/Driver/Driver.cpp",5019,"const char *Driver::CreateTempFile(Compilation &C, StringRef Prefix, StringRef Suffix, bool MultipleArchs, StringRef BoundArch, bool NeedUniqueDirectory) const {\n  if (CrashDirectory) {\n    if (std::error_code EC = llvm::sys::fs::createUniqueFile(Path + Middle + Suffix, TmpName)) {\n      Diag(clang::diag::err_unable_to_make_temp) << EC.message();"},{"clang/lib/Driver/Driver.cpp",5363,"std::string Driver::GetTemporaryPath(StringRef Prefix, StringRef Suffix) const {\n  if (EC) {\n    Diag(clang::diag::err_unable_to_make_temp) << EC.message();"},{"clang/lib/Driver/Driver.cpp",5374,"std::string Driver::GetTemporaryDirectory(StringRef Prefix) const {\n  if (EC) {\n    Diag(clang::diag::err_unable_to_make_temp) << EC.message();"},{"clang/lib/Driver/ToolChains/HIPUtility.cpp",139,"/// Add Generated HIP Object File which has device images embedded into the\n/// host to the argument list for linking. Using MC directives, embed the\n/// device code and also define symbols required by the code generation so that\n/// the image can be retrieved at runtime.\nvoid HIP::constructGenerateObjFileFromHIPFatBinary(Compilation &C, const InputInfo &Output, const InputInfoList &Inputs, const ArgList &Args, const JobAction &JA, const Tool &T) {\n  if (EC) {\n    C.getDriver().Diag(clang::diag::err_unable_to_make_temp) << EC.message();"}}

[j]={{"clang/lib/Frontend/CompilerInstance.cpp",640,"void CompilerInstance::clearOutputFiles(bool EraseFiles) {\n  // Ignore errors that occur when trying to discard the temp file.\n  for (OutputFile &OF : OutputFiles) {\n    getDiagnostics().Report(diag::err_unable_to_rename_temp) << OF.File->TmpName << OF.Filename << std::move(E);"}}

[j]={{"clang/lib/ARCMigrate/TransAPIUses.cpp",82,"class APIChecker : public RecursiveASTVisitor<APIChecker> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {\n    if (E->isInstanceMessage() && E->getInstanceReceiver() && E->getSelector() == zoneSel && Pass.TA.hasDiagnostic(diag::err_unavailable, diag::err_unavailable_message, E->getSelectorLoc(0))) {"},{"clang/lib/ARCMigrate/TransAPIUses.cpp",85,"class APIChecker : public RecursiveASTVisitor<APIChecker> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {\n    // -zone.\n    if (E->isInstanceMessage() && E->getInstanceReceiver() && E->getSelector() == zoneSel && Pass.TA.hasDiagnostic(diag::err_unavailable, diag::err_unavailable_message, E->getSelectorLoc(0))) {\n      Pass.TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message, E->getSelectorLoc(0));"},{"clang/lib/ARCMigrate/TransAutoreleasePool.cpp",198,"class AutoreleasePoolRewriter : public RecursiveASTVisitor<AutoreleasePoolRewriter> {\n  void clearUnavailableDiags(Stmt *S) {\n    if (S)\n      Pass.TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message, S->getSourceRange());"},{"clang/lib/ARCMigrate/TransGCCalls.cpp",50,"class GCCollectableCallsChecker : public RecursiveASTVisitor<GCCollectableCallsChecker> {\n  bool VisitCallExpr(CallExpr *E) {\n    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) {\n      if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(DRE->getDecl())) {\n        if (FD->getIdentifier() == NSMakeCollectableII) {\n          TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message,"},{"clang/lib/ARCMigrate/TransRetainReleaseDealloc.cpp",364,"class RetainReleaseDeallocRemover : public RecursiveASTVisitor<RetainReleaseDeallocRemover> {\n  void clearDiagnostics(SourceLocation loc) const { Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message, diag::err_unavailable, diag::err_unavailable_message, loc); }"},{zc,760,"bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {\n  if (DiagID == diag::err_unavailable || DiagID == diag::err_unavailable_message)"},{"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;"}}

[j]={{"clang/lib/Sema/SemaAvailability.cpp",394,"/// 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    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        // Most of these failures are due to extra restrictions in ARC;\n        // reflect that in the primary diagnostic when applicable.\n        auto flagARCError = [&] {\n          if (S.getLangOpts().ObjCAutoRefCount && S.getSourceManager().isInSystemHeader(OffendingDecl->getLocation()))\n            diag = diag::err_unavailable_in_arc;"}}

[j]={{"clang/lib/ARCMigrate/TransAPIUses.cpp",82,"class APIChecker : public RecursiveASTVisitor<APIChecker> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {\n    if (E->isInstanceMessage() && E->getInstanceReceiver() && E->getSelector() == zoneSel && Pass.TA.hasDiagnostic(diag::err_unavailable, diag::err_unavailable_message, E->getSelectorLoc(0))) {"},{"clang/lib/ARCMigrate/TransAPIUses.cpp",85,"class APIChecker : public RecursiveASTVisitor<APIChecker> {\n  bool VisitObjCMessageExpr(ObjCMessageExpr *E) {\n    // -zone.\n    if (E->isInstanceMessage() && E->getInstanceReceiver() && E->getSelector() == zoneSel && Pass.TA.hasDiagnostic(diag::err_unavailable, diag::err_unavailable_message, E->getSelectorLoc(0))) {\n      Pass.TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message, E->getSelectorLoc(0));"},{"clang/lib/ARCMigrate/TransAutoreleasePool.cpp",198,"class AutoreleasePoolRewriter : public RecursiveASTVisitor<AutoreleasePoolRewriter> {\n  void clearUnavailableDiags(Stmt *S) {\n    if (S)\n      Pass.TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message, S->getSourceRange());"},{"clang/lib/ARCMigrate/TransGCCalls.cpp",50,"class GCCollectableCallsChecker : public RecursiveASTVisitor<GCCollectableCallsChecker> {\n  bool VisitCallExpr(CallExpr *E) {\n    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) {\n      if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(DRE->getDecl())) {\n        if (FD->getIdentifier() == NSMakeCollectableII) {\n          TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message,"},{"clang/lib/ARCMigrate/TransRetainReleaseDealloc.cpp",364,"class RetainReleaseDeallocRemover : public RecursiveASTVisitor<RetainReleaseDeallocRemover> {\n  void clearDiagnostics(SourceLocation loc) const { Pass.TA.clearDiagnostic(diag::err_arc_illegal_explicit_message, diag::err_unavailable, diag::err_unavailable_message, loc); }"},{zc,760,"bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {\n  if (DiagID == diag::err_unavailable || DiagID == diag::err_unavailable_message)"},{"clang/lib/Sema/SemaAvailability.cpp",383,"/// 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_message = diag::err_unavailable_message;"}}

[j]={{y,18676,"static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {\n  while (true) {\n    if (CallExpr *call = dyn_cast<CallExpr>(E)) {\n      diagID = diag::err_uncasted_call_of_unknown_any;"},{y,18691,"static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {\n  if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {\n  } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {\n  } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {\n    diagID = diag::err_uncasted_call_of_unknown_any;"}}

[j]={{y,18695,"static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {\n  if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {\n  } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {\n  } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {\n    if (!d) {\n      S.Diag(loc, diag::err_uncasted_send_to_unknown_any_method) << static_cast<unsigned>(msg->isClassMessage()) << msg->getSelector() << orig->getSourceRange();"}}

[j]={{y,18671,"static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {\n  unsigned diagID = diag::err_uncasted_use_of_unknown_any;"}}

[j]={{Zb,139,"/// Emits an error if the given method does not exist, or if the return\n/// type is not an Objective-C object.\nstatic bool validateBoxingMethod(Sema &S, SourceLocation Loc, const ObjCInterfaceDecl *Class, Selector Sel, const ObjCMethodDecl *Method) {\n  if (!Method) {\n    S.Diag(Loc, diag::err_undeclared_boxing_method) << Sel << Class->getName();"}}

[j]={{V,407,"ParsedType Sema::getDestructorName(SourceLocation TildeLoc, IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec &SS, ParsedType ObjectTypePtr, bool EnteringContext) {\n  if (FoundDecls.empty()) {\n    Diag(NameLoc, diag::err_undeclared_destructor_name) << &II << MakeFixItHint();"}}

[j]={{w,2002,"static void CheckPoppedLabel(LabelDecl *L, Sema &S, Sema::DiagReceiverTy DiagReceiver) {\n  if (Diagnose)\n    DiagReceiver(L->getLocation(), S.PDiag(diag::err_undeclared_label_use) << L);"}}

[j]={{Zb,184,"/// Validates ObjCInterfaceDecl availability.\n/// ObjCInterfaceDecl, used to create ObjC literals, should be defined\n/// if clang not in a debugger mode.\nstatic bool ValidateObjCLiteralInterfaceDecl(Sema &S, ObjCInterfaceDecl *Decl, SourceLocation Loc, Sema::ObjCLiteralKind LiteralKind) {\n  if (!Decl) {\n    S.Diag(Loc, diag::err_undeclared_objc_literal_class) << II->getName() << LiteralKind;"},{Zb,187,"/// Validates ObjCInterfaceDecl availability.\n/// ObjCInterfaceDecl, used to create ObjC literals, should be defined\n/// if clang not in a debugger mode.\nstatic bool ValidateObjCLiteralInterfaceDecl(Sema &S, ObjCInterfaceDecl *Decl, SourceLocation Loc, Sema::ObjCLiteralKind LiteralKind) {\n  if (!Decl) {\n  } else if (!Decl->hasDefinition() && !S.getLangOpts().DebuggerObjCLiteral) {\n    S.Diag(Loc, diag::err_undeclared_objc_literal_class) << Decl->getName() << LiteralKind;"}}

[j]={{ob,1057,"/// FindProtocolDeclaration - This routine looks up protocols and\n/// issues an error if they are not declared. It returns list of\n/// protocol declarations in its \'Protocols\' argument.\nvoid Sema::FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer, ArrayRef<IdentifierLocPair> ProtocolId, SmallVectorImpl<Decl *> &Protocols) {\n  for (const IdentifierLocPair &Pair : ProtocolId) {\n    if (!PDecl) {\n      Diag(Pair.second, diag::err_undeclared_protocol) << Pair.first;"},{ob,1409,"void Sema::actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef<IdentifierInfo *> identifiers, ArrayRef<SourceLocation> identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols) {\n  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {\n    Diag(identifierLocs[i], (lookupKind == LookupAnyName ? diag::err_objc_type_arg_missing : lookupKind == LookupObjCProtocolName ? diag::err_undeclared_protocol : diag::err_unknown_typename)) << identifiers[i];"},{Zb,1120,"ExprResult Sema::ParseObjCProtocolExpression(IdentifierInfo *ProtocolId, SourceLocation AtLoc, SourceLocation ProtoLoc, SourceLocation LParenLoc, SourceLocation ProtoIdLoc, SourceLocation RParenLoc) {\n  if (!PDecl) {\n    Diag(ProtoLoc, diag::err_undeclared_protocol) << ProtocolId;"}}

[j]={{ob,1053,"/// FindProtocolDeclaration - This routine looks up protocols and\n/// issues an error if they are not declared. It returns list of\n/// protocol declarations in its \'Protocols\' argument.\nvoid Sema::FindProtocolDeclaration(bool WarnOnDeclarations, bool ForObjCContainer, ArrayRef<IdentifierLocPair> ProtocolId, SmallVectorImpl<Decl *> &Protocols) {\n  for (const IdentifierLocPair &Pair : ProtocolId) {\n    if (!PDecl) {\n      if ((PDecl = Corrected.getCorrectionDeclAs<ObjCProtocolDecl>()))\n        diagnoseTypo(Corrected, PDiag(diag::err_undeclared_protocol_suggest) << Pair.first);"},{ob,1382,"void Sema::actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef<IdentifierInfo *> identifiers, ArrayRef<SourceLocation> identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols) {\n  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {\n    if (corrected) {\n      // Did we find a protocol?\n      if (auto proto = corrected.getCorrectionDeclAs<ObjCProtocolDecl>()) {\n        diagnoseTypo(corrected, PDiag(diag::err_undeclared_protocol_suggest) << identifiers[i]);"}}

[j]={{"clang/lib/Sema/SemaAttr.cpp",666,"void Sema::ActOnPragmaMSAllocText(SourceLocation PragmaLocation, StringRef Section, const SmallVector<std::tuple<IdentifierInfo *, SourceLocation>> &Functions) {\n  for (auto &Function : Functions) {\n    if (!ND) {\n      Diag(Loc, diag::err_undeclared_use) << II->getName();"},{y,2027,"/// Diagnose an empty lookup.\n///\n/// \\return false if new lookup candidates were found\nbool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, TypoExpr **Out) {\n  if (Name.getNameKind() == DeclarationName::CXXOperatorName || Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {\n    diagnostic = diag::err_undeclared_use;"},{E,4274,"/// Form a template name from a name that is syntactically required to name a\n/// template, either due to use of the \'template\' keyword or because a name in\n/// this syntactic context is assumed to name a template (C++ [temp.names]p2-4).\n///\n/// This action forms a template name given the name of the template and its\n/// optional scope specifier. This is used when the \'template\' keyword is used\n/// or when the parsing context unambiguously treats a following \'<\' as\n/// introducing a template argument list. Note that this may produce a\n/// non-dependent template name if we can perform the lookup now and identify\n/// the named template.\n///\n/// For example, given \"x.MetaFun::template apply\", the scope specifier\n/// \\p SS will be \"MetaFun::\", \\p TemplateKWLoc contains the location\n/// of the \"template\" keyword, and \"apply\" is the \\p Name.\nTemplateNameKind Sema::ActOnTemplateName(Scope *S, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, const UnqualifiedId &Name, ParsedType ObjectType, bool EnteringContext, TemplateTy &Result, bool AllowInjectedClassName) {\n  if (!MemberOfUnknownSpecialization) {\n    if (!LookupTemplateName(R, S, SS, ObjectType.get(), EnteringContext, MOUS, RTK, nullptr, /*AllowTypoCorrection=*/false) && !R.isAmbiguous()) {\n      if (LookupCtx)\n      else\n        Diag(Name.getBeginLoc(), diag::err_undeclared_use) << DNI.getName() << SS.getRange();"}}

[j]={{"clang/lib/Lex/ModuleMap.cpp",468,"void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File) {\n  if (RequestingModule && LangOpts.ModulesStrictDeclUse) {\n    Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module) << RequestingModule->getTopLevelModule()->Name << Filename;"}}

[j]={{"clang/lib/Lex/ModuleMap.cpp",458,"void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule, bool RequestingModuleIsModuleInterface, SourceLocation FilenameLoc, StringRef Filename, FileEntryRef File) {\n  // We have found a module, but we don\'t use it.\n  if (NotUsed) {\n    Diags.Report(FilenameLoc, diag::err_undeclared_use_of_module_indirect) << RequestingModule->getTopLevelModule()->Name << Filename << NotUsed->Name;"}}

[j]={{y,2028,"/// Diagnose an empty lookup.\n///\n/// \\return false if new lookup candidates were found\nbool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, TypoExpr **Out) {\n  if (Name.getNameKind() == DeclarationName::CXXOperatorName || Name.getNameKind() == DeclarationName::CXXLiteralOperatorName || Name.getNameKind() == DeclarationName::CXXConversionFunctionName) {\n    diagnostic_suggest = diag::err_undeclared_use_suggest;"}}

[j]={{"clang/lib/Sema/SemaCUDA.cpp",53,"ExprResult Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, MultiExprArg ExecConfig, SourceLocation GGGLoc) {\n  if (!ConfigDecl)\n    return ExprError(Diag(LLLLoc, diag::err_undeclared_var_use) << getCudaConfigureFuncName());"},{"clang/lib/Sema/SemaCXXScopeSpec.cpp",742,"/// Build a new nested-name-specifier for \"identifier::\", as described\n/// by ActOnCXXNestedNameSpecifier.\n///\n/// \\param S Scope in which the nested-name-specifier occurs.\n/// \\param IdInfo Parser information about an identifier in the\n///        nested-name-spec.\n/// \\param EnteringContext If true, enter the context specified by the\n///        nested-name-specifier.\n/// \\param SS Optional nested name specifier preceding the identifier.\n/// \\param ScopeLookupResult Provides the result of name lookup within the\n///        scope of the nested-name-specifier that was computed at template\n///        definition time.\n/// \\param ErrorRecoveryLookup Specifies if the method is called to improve\n///        error recovery and what kind of recovery is performed.\n/// \\param IsCorrectedToColon If not null, suggestion of replace \'::\' -> \':\'\n///        are allowed.  The bool value pointed by this parameter is set to\n///      \'true\' if the identifier is treated as if it was followed by \':\',\n///        not \'::\'.\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in\n/// that it contains an extra parameter \\p ScopeLookupResult, which provides\n/// the result of name lookup within the scope of the nested-name-specifier\n/// that was computed at template definition time.\n///\n/// If ErrorRecoveryLookup is true, then this call is used to improve error\n/// recovery.  This means that it should not emit diagnostics, it should\n/// just return true on failure.  It also means it should only return a valid\n/// scope if it *knows* that the result is correct.  It should not return in a\n/// dependent context, for example. Nor will it extend \\p SS with the scope\n/// specifier.\nbool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon, bool OnlyNamespace) {\n  if (!Found.empty()) {\n  } else if (SS.isSet())\n  else\n    Diag(IdInfo.IdentifierLoc, diag::err_undeclared_var_use) << IdInfo.Identifier;"},{y,2024,"/// Diagnose an empty lookup.\n///\n/// \\return false if new lookup candidates were found\nbool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, TypoExpr **Out) {\n  unsigned diagnostic = diag::err_undeclared_var_use;"},{Cc,1277,"/// 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 (getLangOpts().ObjCDefaultSynthProperties && getLangOpts().ObjCRuntime.isNonFragile() && !IDecl->isObjCRequiresPropertyDefs()) {\n      // Issue diagnostics only if Ivar belongs to current class.\n      if (Ivar && Ivar->getSynthesize() && declaresSameEntity(IC->getClassInterface(), ClassDeclared)) {\n        Diag(Ivar->getLocation(), diag::err_undeclared_var_use) << PropertyId;"},{Ec,2461,"ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec, const DeclarationNameInfo &Id, OpenMPDirectiveKind Kind) {\n  if (!Lookup.isSingleResult()) {\n    if (TypoCorrection Corrected = CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr, CCC, CTK_ErrorRecovery)) {\n    } else {\n      Diag(Id.getLoc(), Lookup.empty() ? diag::err_undeclared_var_use : diag::err_omp_expected_var_arg) << Id.getName();"},{Ec,18856,"NamedDecl *Sema::lookupOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec, const DeclarationNameInfo &Id) {\n  if (!Lookup.isSingleResult()) {\n    Diag(Id.getLoc(), diag::err_undeclared_var_use) << Id.getName();"}}

[j]={{"clang/lib/Sema/SemaCXXScopeSpec.cpp",571,"/// Build a new nested-name-specifier for \"identifier::\", as described\n/// by ActOnCXXNestedNameSpecifier.\n///\n/// \\param S Scope in which the nested-name-specifier occurs.\n/// \\param IdInfo Parser information about an identifier in the\n///        nested-name-spec.\n/// \\param EnteringContext If true, enter the context specified by the\n///        nested-name-specifier.\n/// \\param SS Optional nested name specifier preceding the identifier.\n/// \\param ScopeLookupResult Provides the result of name lookup within the\n///        scope of the nested-name-specifier that was computed at template\n///        definition time.\n/// \\param ErrorRecoveryLookup Specifies if the method is called to improve\n///        error recovery and what kind of recovery is performed.\n/// \\param IsCorrectedToColon If not null, suggestion of replace \'::\' -> \':\'\n///        are allowed.  The bool value pointed by this parameter is set to\n///      \'true\' if the identifier is treated as if it was followed by \':\',\n///        not \'::\'.\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in\n/// that it contains an extra parameter \\p ScopeLookupResult, which provides\n/// the result of name lookup within the scope of the nested-name-specifier\n/// that was computed at template definition time.\n///\n/// If ErrorRecoveryLookup is true, then this call is used to improve error\n/// recovery.  This means that it should not emit diagnostics, it should\n/// just return true on failure.  It also means it should only return a valid\n/// scope if it *knows* that the result is correct.  It should not return in a\n/// dependent context, for example. Nor will it extend \\p SS with the scope\n/// specifier.\nbool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon, bool OnlyNamespace) {\n  if (Found.empty() && !ErrorRecoveryLookup && !getLangOpts().MSVCCompat) {\n    if (TypoCorrection Corrected = CorrectTypo(Found.getLookupNameInfo(), Found.getLookupKind(), S, &SS, CCC, CTK_ErrorRecovery, LookupCtx, EnteringContext)) {\n      if (LookupCtx) {\n      } else\n        diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest) << Name);"},{w,889,"Corrected:\n  case LookupResult::NotFound:\n    // Perform typo correction to determine if there is another name that is\n    // close to this name.\n    if (!SecondTry && CCC) {\n      if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S, &SS, *CCC, CTK_ErrorRecovery)) {\n        unsigned UnqualifiedDiag = diag::err_undeclared_var_use_suggest;"},{y,2025,"/// Diagnose an empty lookup.\n///\n/// \\return false if new lookup candidates were found\nbool Sema::DiagnoseEmptyLookup(Scope *S, CXXScopeSpec &SS, LookupResult &R, CorrectionCandidateCallback &CCC, TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args, TypoExpr **Out) {\n  unsigned diagnostic_suggest = diag::err_undeclared_var_use_suggest;"},{Ec,2458,"ExprResult Sema::ActOnOpenMPIdExpression(Scope *CurScope, CXXScopeSpec &ScopeSpec, const DeclarationNameInfo &Id, OpenMPDirectiveKind Kind) {\n  if (!Lookup.isSingleResult()) {\n    if (TypoCorrection Corrected = CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr, CCC, CTK_ErrorRecovery)) {\n      diagnoseTypo(Corrected, PDiag(Lookup.empty() ? diag::err_undeclared_var_use_suggest : diag::err_omp_expected_var_arg_suggest) << Id.getName());"},{Ec,18851,"NamedDecl *Sema::lookupOpenMPDeclareTargetName(Scope *CurScope, CXXScopeSpec &ScopeSpec, const DeclarationNameInfo &Id) {\n  if (!Lookup.isSingleResult()) {\n    if (TypoCorrection Corrected = CorrectTypo(Id, LookupOrdinaryName, CurScope, nullptr, CCC, CTK_ErrorRecovery)) {\n      diagnoseTypo(Corrected, PDiag(diag::err_undeclared_var_use_suggest) << Id.getName());"}}

[j]={{ob,1485,"ObjCCategoryDecl *Sema::ActOnStartCategoryInterface(SourceLocation AtInterfaceLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, ObjCTypeParamList *typeParamList, IdentifierInfo *CategoryName, SourceLocation CategoryLoc, Decl *const *ProtoRefs, unsigned NumProtoRefs, const SourceLocation *ProtoLocs, SourceLocation EndProtoLoc, const ParsedAttributesView &AttrList) {\n  if (!IDecl || RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl), diag::err_category_forward_interface, CategoryName == nullptr)) {\n    if (!IDecl)\n      Diag(ClassLoc, diag::err_undef_interface) << ClassName;"},{ob,1559,"/// ActOnStartCategoryImplementation - Perform semantic checks on the\n/// category implementation declaration and build an ObjCCategoryImplDecl\n/// object.\nObjCCategoryImplDecl *Sema::ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *CatName, SourceLocation CatLoc, const ParsedAttributesView &Attrs) {\n  /// Check that class of this category is already completely declared.\n  if (!IDecl) {\n    Diag(ClassLoc, diag::err_undef_interface) << ClassName;"},{ob,1561,"/// ActOnStartCategoryImplementation - Perform semantic checks on the\n/// category implementation declaration and build an ObjCCategoryImplDecl\n/// object.\nObjCCategoryImplDecl *Sema::ActOnStartCategoryImplementation(SourceLocation AtCatImplLoc, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *CatName, SourceLocation CatLoc, const ParsedAttributesView &Attrs) {\n  } else if (RequireCompleteType(ClassLoc, Context.getObjCInterfaceType(IDecl), diag::err_undef_interface)) {"},{ob,4249,"/// Called whenever \\@defs(ClassName) is encountered in the source.  Inserts the\n/// instance variables of ClassName into Decls.\nvoid Sema::ActOnDefs(Scope *S, Decl *TagD, SourceLocation DeclStart, IdentifierInfo *ClassName, SmallVectorImpl<Decl *> &Decls) {\n  if (!Class) {\n    Diag(DeclStart, diag::err_undef_interface) << ClassName;"}}

[j]={{w,2097,"/// Look for an Objective-C class in the translation unit.\n///\n/// \\param Id The name of the Objective-C class we\'re looking for. If\n/// typo-correction fixes this name, the Id will be updated\n/// to the fixed name.\n///\n/// \\param IdLoc The location of the name in the translation unit.\n///\n/// \\param DoTypoCorrection If true, this routine will attempt typo correction\n/// if there is no class with the given name.\n///\n/// \\returns The declaration of the named Objective-C class, or NULL if the\n/// class could not be found.\nObjCInterfaceDecl *Sema::getObjCInterfaceDecl(IdentifierInfo *&Id, SourceLocation IdLoc, bool DoTypoCorrection) {\n  if (!IDecl && DoTypoCorrection) {\n    if (TypoCorrection C = CorrectTypo(DeclarationNameInfo(Id, IdLoc), LookupOrdinaryName, TUScope, nullptr, CCC, CTK_ErrorRecovery)) {\n      diagnoseTypo(C, PDiag(diag::err_undef_interface_suggest) << Id);"}}

[j]={{ob,521,"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 (!isa_and_nonnull<TypedefNameDecl>(PrevDecl)) {\n      if (!SuperClassDecl)\n        Diag(SuperLoc, diag::err_undef_superclass) << SuperName << ClassName << SourceRange(AtInterfaceLoc, ClassLoc);"},{ob,1636,"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    } else {\n      if (!SDecl)\n        Diag(SuperClassLoc, diag::err_undef_superclass) << SuperClassname << ClassName;"}}

[j]={{ob,471,"void Sema::ActOnSuperClassOfClassInterface(Scope *S, SourceLocation AtInterfaceLoc, ObjCInterfaceDecl *IDecl, IdentifierInfo *ClassName, SourceLocation ClassLoc, IdentifierInfo *SuperName, SourceLocation SuperLoc, ArrayRef<ParsedType> SuperTypeArgs, SourceRange SuperTypeArgsRange) {\n  if (!PrevDecl) {\n    if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(SuperName, SuperLoc), LookupOrdinaryName, TUScope, nullptr, CCC, CTK_ErrorRecovery)) {\n      diagnoseTypo(Corrected, PDiag(diag::err_undef_superclass_suggest) << SuperName << ClassName);"}}

[j]={{"clang/lib/Sema/Sema.cpp",813,"/// checkUndefinedButUsed - Check for undefined objects with internal linkage\n/// or that are inline.\nstatic void checkUndefinedButUsed(Sema &S) {\n  for (const auto &Undef : Undefined) {\n    if (S.isExternalWithNoLinkageType(VD)) {\n    } else if (!VD->isExternallyVisible()) {\n    } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {\n    } else {\n      S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;"}}

[j]={{"clang/lib/Sema/Sema.cpp",791,"/// checkUndefinedButUsed - Check for undefined objects with internal linkage\n/// or that are inline.\nstatic void checkUndefinedButUsed(Sema &S) {\n  for (const auto &Undef : Undefined) {\n    if (S.isExternalWithNoLinkageType(VD)) {\n      S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage()) ? diag::ext_undefined_internal_type : diag::err_undefined_internal_type) << isa<VarDecl>(VD) << VD;"}}

[j]={{R,8438,"QualType Sema::BuiltinEnumUnderlyingType(QualType BaseType, SourceLocation Loc) {\n  if (BaseType->isIncompleteType(&FwdDecl)) {\n    Diag(Loc, diag::err_underlying_type_of_incomplete_enum) << BaseType;"}}

[j]={{cb,327,"/// ProcessCharEscape - Parse a standard C escape sequence, which can occur in\n/// either a character or a string literal.\nstatic unsigned ProcessCharEscape(const char *ThisTokBegin, const char *&ThisTokBuf, const char *ThisTokEnd, bool &HadError, FullSourceLoc Loc, unsigned CharWidth, DiagnosticsEngine *Diags, const LangOptions &Features, StringLiteralEvalMethod EvalMethod) {\n  if (EvalMethod == StringLiteralEvalMethod::Unevaluated && !IsEscapeValidInUnevaluatedStringLiteral(Escape)) {\n    Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf, diag::err_unevaluated_string_invalid_escape_sequence) << StringRef(EscapeBegin, ThisTokBuf - EscapeBegin);"}}

[j]={{cb,1761,"void StringLiteralParser::init(ArrayRef<Token> StringToks) {\n  /// (C99 5.1.1.2p1).  The common case is only one string fragment.\n  for (const Token &Tok : StringToks) {\n    // Remember if we see any wide or utf-8/16/32 strings.\n    // Also check for illegal concatenations.\n    if (isUnevaluated() && Tok.getKind() != tok::string_literal) {\n      if (Diags) {\n        Diags->Report(Tok.getLocation(), Features.CPlusPlus26 ? diag::err_unevaluated_string_prefix : diag::warn_unevaluated_string_prefix) << Prefix << Features.CPlusPlus << FixItHint::CreateRemoval(Range);"}}

[j]={{cb,1851,"void StringLiteralParser::init(ArrayRef<Token> StringToks) {\n  for (unsigned i = 0, e = StringToks.size(); i != e; ++i) {\n    // Remove an optional ud-suffix.\n    if (ThisTokEnd[-1] != \'\"\') {\n      if (UDSuffixBuf.empty()) {\n      } else {\n        if (UDSuffixBuf != UDSuffix || UnevaluatedStringHasUDL) {\n          if (Diags) {\n            if (UnevaluatedStringHasUDL) {\n              Diags->Report(TokLoc, diag::err_unevaluated_string_udl) << SourceRange(TokLoc, TokLoc);"}}

[j]={{"clang/lib/Sema/SemaTemplateVariadic.cpp",355,"/// Diagnose all of the unexpanded parameter packs in the given\n/// vector.\nbool Sema::DiagnoseUnexpandedParameterPacks(SourceLocation Loc, UnexpandedParameterPackContext UPPC, ArrayRef<UnexpandedParameterPack> Unexpanded) {\n  auto DB = Diag(Loc, diag::err_unexpanded_parameter_pack) << (int)UPPC << (int)Names.size();"}}

[j]={{F,4249,"/// 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.is(tok::at)) {\n    } else { // Handle @defs\n      if (!Tok.isObjCAtKeyword(tok::objc_defs)) {\n        Diag(Tok, diag::err_unexpected_at);"},{Xb,103,"/// ParseObjCAtDirectives - Handle parts of the external-declaration production:\n///      external-declaration: [C99 6.9]\n/// [OBJC]  objc-class-definition\n/// [OBJC]  objc-class-declaration\n/// [OBJC]  objc-alias-declaration\n/// [OBJC]  objc-protocol-definition\n/// [OBJC]  objc-method-definition\n/// [OBJC]  \'@\' \'end\'\nParser::DeclGroupPtrTy Parser::ParseObjCAtDirectives(ParsedAttributes &DeclAttrs, ParsedAttributes &DeclSpecAttrs) {\n  default:\n    Diag(AtLoc, diag::err_unexpected_at);"},{Xb,2610,"ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {\n  default:\n    if (Tok.getIdentifierInfo() == nullptr)\n      return ExprError(Diag(AtLoc, diag::err_unexpected_at));"},{Xb,2632,"ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {\n  default:\n    default: {\n      if (str) {\n        return ExprError(Diag(AtLoc, diag::err_unexpected_at) << FixItHint::CreateReplacement(kwLoc, str));"},{Xb,2634,"ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {\n  default:\n    default: {\n      if (str) {\n      } else\n        return ExprError(Diag(AtLoc, diag::err_unexpected_at));"}}

[j]={{vb,372,"/// Parse global scope or nested-name-specifier if present.\n///\n/// Parses a C++ global scope specifier (\'::\') or nested-name-specifier (which\n/// may be preceded by \'::\'). Note that this routine will not parse ::new or\n/// ::delete; it will just leave them in the token stream.\n///\n///      \'::\'[opt] nested-name-specifier\n///      \'::\'\n///\n///      nested-name-specifier:\n///        type-name \'::\'\n///        namespace-name \'::\'\n///        nested-name-specifier identifier \'::\'\n///        nested-name-specifier \'template\'[opt] simple-template-id \'::\'\n///\n///\n/// \\param SS the scope specifier that will be set to the parsed\n/// nested-name-specifier (or empty)\n///\n/// \\param ObjectType if this nested-name-specifier is being parsed following\n/// the \".\" or \"->\" of a member access expression, this parameter provides the\n/// type of the object whose members are being accessed.\n///\n/// \\param ObjectHadErrors if this unqualified-id occurs within a member access\n/// expression, indicates whether the original subexpressions had any errors.\n/// When true, diagnostics for missing \'template\' keyword will be supressed.\n///\n/// \\param EnteringContext whether we will be entering into the context of\n/// the nested-name-specifier after parsing it.\n///\n/// \\param MayBePseudoDestructor When non-NULL, points to a flag that\n/// indicates whether this nested-name-specifier may be part of a\n/// pseudo-destructor name. In this case, the flag will be set false\n/// if we don\'t actually end up parsing a destructor name. Moreover,\n/// if we do end up determining that we are parsing a destructor name,\n/// the last component of the nested-name-specifier is not parsed as\n/// part of the scope specifier.\n///\n/// \\param IsTypename If \\c true, this nested-name-specifier is known to be\n/// part of a type name. This is used to improve error recovery.\n///\n/// \\param LastII When non-NULL, points to an IdentifierInfo* that will be\n/// filled in with the leading identifier in the last component of the\n/// nested-name-specifier, if any.\n///\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n///\n/// \\returns true if there was an error parsing a scope specifier\nbool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename, IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {\n  while (true) {\n    // If we get foo:bar, this is almost certainly a typo for foo::bar.  Recover\n    // and emit a fixit hint for it.\n    if (Next.is(tok::colon) && !ColonIsSacred) {\n      if (Actions.IsInvalidUnlessNestedName(getCurScope(), SS, IdInfo, EnteringContext) &&\n        Diag(Next, diag::err_unexpected_colon_in_nested_name_spec) << FixItHint::CreateReplacement(Next.getLocation(), \"::\");"}}

[j]={{z,14914,"NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams) {\n  // C++ [class.friend]p1\n  //  A friend of a class is a function or class....\n  // Note that this sees through typedefs, which is intended.\n  // It *doesn\'t* see through dependent types, which is correct\n  // according to [temp.arg.type]p3:\n  //  If a declaration acquires a function type through a\n  //  type dependent on a template-parameter and this causes\n  //  a declaration that does not use the syntactic form of a\n  //  function declarator to have a function type, the program\n  //  is ill-formed.\n  if (!TInfo->getType()->isFunctionType()) {\n    Diag(Loc, diag::err_unexpected_friend);"}}

[j]={{y,2841,"/// Diagnoses obvious problems with the use of the given declaration\n/// as an expression.  This is only actually called for lookups that\n/// were not overloaded, and it doesn\'t promise that the declaration\n/// will in fact be used.\nstatic bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D, bool AcceptInvalid) {\n  if (isa<ObjCInterfaceDecl>(D)) {\n    S.Diag(Loc, diag::err_unexpected_interface) << D->getDeclName();"}}

[j]={{wb,950,"/// ParseExternalDeclaration:\n///\n/// The `Attrs` that are passed in are C++11 attributes and appertain to the\n/// declaration.\n///\n///      external-declaration: [C99 6.9], declaration: [C++ dcl.dcl]\n///        function-definition\n///        declaration\n/// [GNU]  asm-definition\n/// [GNU]  __extension__ external-declaration\n/// [OBJC]  objc-class-definition\n/// [OBJC]  objc-class-declaration\n/// [OBJC]  objc-alias-declaration\n/// [OBJC]  objc-protocol-definition\n/// [OBJC]  objc-method-definition\n/// [OBJC]  @end\n/// [C++]  linkage-specification\n/// [GNU] asm-definition:\n///        simple-asm-expr \';\'\n/// [C++11] empty-declaration\n/// [C++11] attribute-declaration\n///\n/// [C++11] empty-declaration:\n///          \';\'\n///\n/// [C++0x/GNU] \'extern\' \'template\' declaration\n///\n/// [C++20] module-import-declaration\n///\nParser::DeclGroupPtrTy Parser::ParseExternalDeclaration(ParsedAttributes &Attrs, ParsedAttributes &DeclSpecAttrs, ParsingDeclSpec *DS) {\n  case tok::kw_module:\n    Diag(Tok, diag::err_unexpected_module_decl);"}}

[j]={{y,2846,"/// Diagnoses obvious problems with the use of the given declaration\n/// as an expression.  This is only actually called for lookups that\n/// were not overloaded, and it doesn\'t promise that the declaration\n/// will in fact be used.\nstatic bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D, bool AcceptInvalid) {\n  if (isa<NamespaceDecl>(D)) {\n    S.Diag(Loc, diag::err_unexpected_namespace) << D->getDeclName();"}}

[j]={{L,135,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  if (Tok.is(tok::equal)) {\n    if (attrLoc.isValid())\n      Diag(attrLoc, diag::err_unexpected_namespace_attributes_alias);"}}

[j]={{L,125,"/// ParseNamespace - We know that the current token is a namespace keyword. This\n/// may either be a top level namespace or a block-level namespace alias. If\n/// there was an inline keyword, it has already been parsed.\n///\n///      namespace-definition: [C++: namespace.def]\n///        named-namespace-definition\n///        unnamed-namespace-definition\n///        nested-namespace-definition\n///\n///      named-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] identifier \'{\'\n///        namespace-body \'}\'\n///\n///      unnamed-namespace-definition:\n///        \'inline\'[opt] \'namespace\' attributes[opt] \'{\' namespace-body \'}\'\n///\n///      nested-namespace-definition:\n///        \'namespace\' enclosing-namespace-specifier \'::\' \'inline\'[opt]\n///        identifier \'{\' namespace-body \'}\'\n///\n///      enclosing-namespace-specifier:\n///        identifier\n///        enclosing-namespace-specifier \'::\' \'inline\'[opt] identifier\n///\n///      namespace-alias-definition:  [C++ 7.3.2: namespace.alias]\n///        \'namespace\' identifier \'=\' qualified-namespace-specifier \';\'\n///\nParser::DeclGroupPtrTy Parser::ParseNamespace(DeclaratorContext Context, SourceLocation &DeclEnd, SourceLocation InlineLoc) {\n  // A nested namespace definition cannot have attributes.\n  if (!ExtraNSs.empty() && attrLoc.isValid())\n    Diag(attrLoc, diag::err_unexpected_nested_namespace_attribute);"}}

[j]={{Xb,1950,"///  objc-implementation:\n///    objc-class-implementation-prologue\n///    objc-category-implementation-prologue\n///\n///  objc-class-implementation-prologue:\n///    @implementation identifier objc-superclass[opt]\n///      objc-class-instance-variables[opt]\n///\n///  objc-category-implementation-prologue:\n///    @implementation identifier ( identifier )\nParser::DeclGroupPtrTy Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc, ParsedAttributes &Attrs) {\n  // Neither a type parameter list nor a list of protocol references is\n  // permitted here. Parse and diagnose them.\n  if (Tok.is(tok::less)) {\n    if (parseObjCTypeParamListOrProtocolRefs(typeParamScope, lAngleLoc, protocolIdents, rAngleLoc)) {\n    } else if (lAngleLoc.isValid()) {\n      Diag(lAngleLoc, diag::err_unexpected_protocol_qualifier) << FixItHint::CreateRemoval(SourceRange(lAngleLoc, rAngleLoc));"},{Xb,1980,"///  objc-implementation:\n///    objc-class-implementation-prologue\n///    objc-category-implementation-prologue\n///\n///  objc-class-implementation-prologue:\n///    @implementation identifier objc-superclass[opt]\n///      objc-class-instance-variables[opt]\n///\n///  objc-category-implementation-prologue:\n///    @implementation identifier ( identifier )\nParser::DeclGroupPtrTy Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc, ParsedAttributes &Attrs) {\n  if (Tok.is(tok::l_paren)) {\n    if (Tok.is(tok::less)) { // we have illegal \'<\' try to recover\n      Diag(Tok, diag::err_unexpected_protocol_qualifier);"},{Xb,2007,"///  objc-implementation:\n///    objc-class-implementation-prologue\n///    objc-category-implementation-prologue\n///\n///  objc-class-implementation-prologue:\n///    @implementation identifier objc-superclass[opt]\n///      objc-class-instance-variables[opt]\n///\n///  objc-category-implementation-prologue:\n///    @implementation identifier ( identifier )\nParser::DeclGroupPtrTy Parser::ParseObjCAtImplementationDeclaration(SourceLocation AtLoc, ParsedAttributes &Attrs) {\n  if (Tok.is(tok::l_paren)) {\n  } else {\n    if (Tok.is(tok::l_brace)) // we have ivars\n    else if (Tok.is(tok::less)) { // we have illegal \'<\' try to recover\n      Diag(Tok, diag::err_unexpected_protocol_qualifier);"}}

[j]={{L,1121,"/// ParseBaseTypeSpecifier - Parse a C++ base-type-specifier which is either a\n/// class name or decltype-specifier. Note that we only check that the result\n/// names a type; semantic analysis will need to verify that the type names a\n/// class. The result is either a type or null, depending on whether a type\n/// name was found.\n///\n///      base-type-specifier: [C++11 class.derived]\n///        class-or-decltype\n///      class-or-decltype: [C++11 class.derived]\n///        nested-name-specifier[opt] class-name\n///        decltype-specifier\n///      class-name: [C++ class.name]\n///        identifier\n///        simple-template-id\n///\n/// In C++98, instead of base-type-specifier, we have:\n///\n///        ::[opt] nested-name-specifier[opt] class-name\nTypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc, SourceLocation &EndLocation) {\n  // Parse decltype-specifier\n  // tok == kw_decltype is just error recovery, it can only happen when SS\n  // isn\'t empty\n  if (Tok.isOneOf(tok::kw_decltype, tok::annot_decltype)) {\n    if (SS.isNotEmpty())\n      Diag(SS.getBeginLoc(), diag::err_unexpected_scope_on_base_decltype) << FixItHint::CreateRemoval(SS.getRange());"}}

[j]={{L,437,"/// ParseUsingDirectiveOrDeclaration - Parse C++ using using-declaration or\n/// using-directive. Assumes that current token is \'using\'.\nParser::DeclGroupPtrTy Parser::ParseUsingDirectiveOrDeclaration(DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, SourceLocation &DeclEnd, ParsedAttributes &Attrs) {\n  // Consume unexpected \'template\' keywords.\n  while (Tok.is(tok::kw_template)) {\n    Diag(TemplateLoc, diag::err_unexpected_template_after_using) << FixItHint::CreateRemoval(TemplateLoc);"},{L,2396,"/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.\n///\n///      member-declaration:\n///        decl-specifier-seq[opt] member-declarator-list[opt] \';\'\n///        function-definition \';\'[opt]\n///        ::[opt] nested-name-specifier template[opt] unqualified-id \';\'[TODO]\n///        using-declaration                                            [TODO]\n/// [C++0x] static_assert-declaration\n///        template-declaration\n/// [GNU]  \'__extension__\' member-declaration\n///\n///      member-declarator-list:\n///        member-declarator\n///        member-declarator-list \',\' member-declarator\n///\n///      member-declarator:\n///        declarator virt-specifier-seq[opt] pure-specifier[opt]\n/// [C++2a] declarator requires-clause\n///        declarator constant-initializer[opt]\n/// [C++11] declarator brace-or-equal-initializer[opt]\n///        identifier[opt] \':\' constant-expression\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\n///\n///      virt-specifier:\n///        override\n///        final\n/// [MS]    sealed\n///\n///      pure-specifier:\n///        \'= 0\'\n///\n///      constant-initializer:\n///        \'=\' constant-expression\n///\nParser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, ParsedAttributes &AccessAttrs, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject *TemplateDiags) {\n  if (Tok.is(tok::kw_using)) {\n    // Consume unexpected \'template\' keywords.\n    while (Tok.is(tok::kw_template)) {\n      Diag(TemplateLoc, diag::err_unexpected_template_after_using) << FixItHint::CreateRemoval(TemplateLoc);"}}

[j]={{vb,2752,"/// Parse a C++ unqualified-id (or a C identifier), which describes the\n/// name of an entity.\n///\n/// \\code\n///      unqualified-id: [C++ expr.prim.general]\n///        identifier\n///        operator-function-id\n///        conversion-function-id\n/// [C++0x] literal-operator-id [TODO]\n///        ~ class-name\n///        template-id\n///\n/// \\endcode\n///\n/// \\param SS The nested-name-specifier that preceded this unqualified-id. If\n/// non-empty, then we are parsing the unqualified-id of a qualified-id.\n///\n/// \\param ObjectType if this unqualified-id occurs within a member access\n/// expression, the type of the base object whose member is being accessed.\n///\n/// \\param ObjectHadErrors if this unqualified-id occurs within a member access\n/// expression, indicates whether the original subexpressions had any errors.\n/// When true, diagnostics for missing \'template\' keyword will be supressed.\n///\n/// \\param EnteringContext whether we are entering the scope of the\n/// nested-name-specifier.\n///\n/// \\param AllowDestructorName whether we allow parsing of a destructor name.\n///\n/// \\param AllowConstructorName whether we allow parsing a constructor name.\n///\n/// \\param AllowDeductionGuide whether we allow parsing a deduction guide name.\n///\n/// \\param Result on a successful parse, contains the parsed unqualified-id.\n///\n/// \\returns true if parsing fails, false otherwise.\nbool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result) {\n  if (getLangOpts().CPlusPlus && (AllowDestructorName || SS.isSet()) && Tok.is(tok::tilde)) {\n    if (TemplateSpecified) {\n      Diag(*TemplateKWLoc, diag::err_unexpected_template_in_destructor_name) << Tok.getLocation();"}}

[j]={{vb,2617,"/// Parse a C++ unqualified-id (or a C identifier), which describes the\n/// name of an entity.\n///\n/// \\code\n///      unqualified-id: [C++ expr.prim.general]\n///        identifier\n///        operator-function-id\n///        conversion-function-id\n/// [C++0x] literal-operator-id [TODO]\n///        ~ class-name\n///        template-id\n///\n/// \\endcode\n///\n/// \\param SS The nested-name-specifier that preceded this unqualified-id. If\n/// non-empty, then we are parsing the unqualified-id of a qualified-id.\n///\n/// \\param ObjectType if this unqualified-id occurs within a member access\n/// expression, the type of the base object whose member is being accessed.\n///\n/// \\param ObjectHadErrors if this unqualified-id occurs within a member access\n/// expression, indicates whether the original subexpressions had any errors.\n/// When true, diagnostics for missing \'template\' keyword will be supressed.\n///\n/// \\param EnteringContext whether we are entering the scope of the\n/// nested-name-specifier.\n///\n/// \\param AllowDestructorName whether we allow parsing of a destructor name.\n///\n/// \\param AllowConstructorName whether we allow parsing a constructor name.\n///\n/// \\param AllowDeductionGuide whether we allow parsing a deduction guide name.\n///\n/// \\param Result on a successful parse, contains the parsed unqualified-id.\n///\n/// \\returns true if parsing fails, false otherwise.\nbool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result) {\n  if (Tok.is(tok::kw_template)) {\n    if (TemplateKWLoc && (ObjectType || SS.isSet())) {\n    } else {\n      Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id) << FixItHint::CreateRemoval(TemplateLoc);"},{vb,2704,"/// Parse a C++ unqualified-id (or a C identifier), which describes the\n/// name of an entity.\n///\n/// \\code\n///      unqualified-id: [C++ expr.prim.general]\n///        identifier\n///        operator-function-id\n///        conversion-function-id\n/// [C++0x] literal-operator-id [TODO]\n///        ~ class-name\n///        template-id\n///\n/// \\endcode\n///\n/// \\param SS The nested-name-specifier that preceded this unqualified-id. If\n/// non-empty, then we are parsing the unqualified-id of a qualified-id.\n///\n/// \\param ObjectType if this unqualified-id occurs within a member access\n/// expression, the type of the base object whose member is being accessed.\n///\n/// \\param ObjectHadErrors if this unqualified-id occurs within a member access\n/// expression, indicates whether the original subexpressions had any errors.\n/// When true, diagnostics for missing \'template\' keyword will be supressed.\n///\n/// \\param EnteringContext whether we are entering the scope of the\n/// nested-name-specifier.\n///\n/// \\param AllowDestructorName whether we allow parsing of a destructor name.\n///\n/// \\param AllowConstructorName whether we allow parsing a constructor name.\n///\n/// \\param AllowDeductionGuide whether we allow parsing a deduction guide name.\n///\n/// \\param Result on a successful parse, contains the parsed unqualified-id.\n///\n/// \\returns true if parsing fails, false otherwise.\nbool Parser::ParseUnqualifiedId(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool AllowDestructorName, bool AllowConstructorName, bool AllowDeductionGuide, SourceLocation *TemplateKWLoc, UnqualifiedId &Result) {\n  // unqualified-id:\n  //  template-id (already parsed and annotated)\n  if (Tok.is(tok::annot_template_id)) {\n    if (TemplateLoc.isValid()) {\n      if (TemplateKWLoc && (ObjectType || SS.isSet()))\n      else\n        Diag(TemplateLoc, diag::err_unexpected_template_in_unqualified_id) << FixItHint::CreateRemoval(TemplateLoc);"}}

[j]={{vb,397,"/// Parse global scope or nested-name-specifier if present.\n///\n/// Parses a C++ global scope specifier (\'::\') or nested-name-specifier (which\n/// may be preceded by \'::\'). Note that this routine will not parse ::new or\n/// ::delete; it will just leave them in the token stream.\n///\n///      \'::\'[opt] nested-name-specifier\n///      \'::\'\n///\n///      nested-name-specifier:\n///        type-name \'::\'\n///        namespace-name \'::\'\n///        nested-name-specifier identifier \'::\'\n///        nested-name-specifier \'template\'[opt] simple-template-id \'::\'\n///\n///\n/// \\param SS the scope specifier that will be set to the parsed\n/// nested-name-specifier (or empty)\n///\n/// \\param ObjectType if this nested-name-specifier is being parsed following\n/// the \".\" or \"->\" of a member access expression, this parameter provides the\n/// type of the object whose members are being accessed.\n///\n/// \\param ObjectHadErrors if this unqualified-id occurs within a member access\n/// expression, indicates whether the original subexpressions had any errors.\n/// When true, diagnostics for missing \'template\' keyword will be supressed.\n///\n/// \\param EnteringContext whether we will be entering into the context of\n/// the nested-name-specifier after parsing it.\n///\n/// \\param MayBePseudoDestructor When non-NULL, points to a flag that\n/// indicates whether this nested-name-specifier may be part of a\n/// pseudo-destructor name. In this case, the flag will be set false\n/// if we don\'t actually end up parsing a destructor name. Moreover,\n/// if we do end up determining that we are parsing a destructor name,\n/// the last component of the nested-name-specifier is not parsed as\n/// part of the scope specifier.\n///\n/// \\param IsTypename If \\c true, this nested-name-specifier is known to be\n/// part of a type name. This is used to improve error recovery.\n///\n/// \\param LastII When non-NULL, points to an IdentifierInfo* that will be\n/// filled in with the leading identifier in the last component of the\n/// nested-name-specifier, if any.\n///\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n///\n/// \\returns true if there was an error parsing a scope specifier\nbool Parser::ParseOptionalCXXScopeSpecifier(CXXScopeSpec &SS, ParsedType ObjectType, bool ObjectHadErrors, bool EnteringContext, bool *MayBePseudoDestructor, bool IsTypename, IdentifierInfo **LastII, bool OnlyNamespace, bool InUsingDeclaration) {\n  while (true) {\n    if (Next.is(tok::coloncolon)) {\n      if (ColonIsSacred) {\n        if (Next2.is(tok::kw_private) || Next2.is(tok::kw_protected) || Next2.is(tok::kw_public) || Next2.is(tok::kw_virtual)) {\n          Diag(Next2, diag::err_unexpected_token_in_nested_name_spec) << Next2.getName() << FixItHint::CreateReplacement(Next.getLocation(), \":\");"}}

[j]={{y,2836,"/// Diagnoses obvious problems with the use of the given declaration\n/// as an expression.  This is only actually called for lookups that\n/// were not overloaded, and it doesn\'t promise that the declaration\n/// will in fact be used.\nstatic bool CheckDeclInExpr(Sema &S, SourceLocation Loc, NamedDecl *D, bool AcceptInvalid) {\n  if (isa<TypedefNameDecl>(D)) {\n    S.Diag(Loc, diag::err_unexpected_typedef) << D->getDeclName();"}}

[j]={{F,6537,"/// ParseFunctionDeclaratorIdentifierList - While parsing a function declarator\n/// we found a K&R-style identifier list instead of a typed parameter list.\n///\n/// After returning, ParamInfo will hold the parsed parameters.\n///\n///      identifier-list: [C99 6.7.5]\n///        identifier\n///        identifier-list \',\' identifier\n///\nvoid Parser::ParseFunctionDeclaratorIdentifierList(Declarator &D, SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo) {\n  do {\n    // Reject \'typedef int y; int test(x, y)\', but continue parsing.\n    if (Actions.getTypeName(*ParmII, Tok.getLocation(), getCurScope()))\n      Diag(Tok, diag::err_unexpected_typedef_ident) << ParmII;"}}

[j]={{F,5935,"/// ParseDirectDeclarator\n///      direct-declarator: [C99 6.7.5]\n/// [C99]  identifier\n///        \'(\' declarator \')\'\n/// [GNU]  \'(\' attributes declarator \')\'\n/// [C90]  direct-declarator \'[\' constant-expression[opt] \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list[opt] assignment-expr[opt] \']\'\n/// [C99]  direct-declarator \'[\' \'static\' type-qual-list[opt] assign-expr \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list \'static\' assignment-expr \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list[opt] \'*\' \']\'\n/// [C++11] direct-declarator \'[\' constant-expression[opt] \']\'\n///                    attribute-specifier-seq[opt]\n///        direct-declarator \'(\' parameter-type-list \')\'\n///        direct-declarator \'(\' identifier-list[opt] \')\'\n/// [GNU]  direct-declarator \'(\' parameter-forward-declarations\n///                    parameter-type-list[opt] \')\'\n/// [C++]  direct-declarator \'(\' parameter-declaration-clause \')\'\n///                    cv-qualifier-seq[opt] exception-specification[opt]\n/// [C++11] direct-declarator \'(\' parameter-declaration-clause \')\'\n///                    attribute-specifier-seq[opt] cv-qualifier-seq[opt]\n///                    ref-qualifier[opt] exception-specification[opt]\n/// [C++]  declarator-id\n/// [C++11] declarator-id attribute-specifier-seq[opt]\n///\n///      declarator-id: [C++ 8]\n///        \'...\'[opt] id-expression\n///        \'::\'[opt] nested-name-specifier[opt] type-name\n///\n///      id-expression: [C++ 5.1]\n///        unqualified-id\n///        qualified-id\n///\n///      unqualified-id: [C++ 5.1]\n///        identifier\n///        operator-function-id\n///        conversion-function-id\n///          \'~\' class-name\n///        template-id\n///\n/// C++17 adds the following, which we also handle here:\n///\n///      simple-declaration:\n///        <decl-spec> \'[\' identifier-list \']\' brace-or-equal-initializer \';\'\n///\n/// Note, any additional constructs added here may need corresponding changes\n/// in isConstructorDeclarator.\nvoid Parser::ParseDirectDeclarator(Declarator &D) {\n  if (getLangOpts().CPlusPlus && D.mayHaveIdentifier()) {\n  } else if (Tok.is(tok::identifier) && D.mayHaveIdentifier()) {\n  } else if (Tok.is(tok::identifier) && !D.mayHaveIdentifier()) {\n    if (DiagnoseIdentifier) {\n      Diag(Tok.getLocation(), diag::err_unexpected_unqualified_id) << FixItHint::CreateRemoval(Tok.getLocation());"}}

[j]={{y,6864,"/// Prepares for a scalar cast, performing all the necessary stages\n/// except the final cast and returning the kind required.\nCastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {\n  case Type::STK_FixedPoint:\n    case Type::STK_FloatingComplex:\n      Diag(Src.get()->getExprLoc(), diag::err_unimplemented_conversion_with_fixed_point_type) << DestTy;"},{y,6952,"/// Prepares for a scalar cast, performing all the necessary stages\n/// except the final cast and returning the kind required.\nCastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {\n  case Type::STK_FloatingComplex:\n    case Type::STK_FixedPoint:\n      Diag(Src.get()->getExprLoc(), diag::err_unimplemented_conversion_with_fixed_point_type) << SrcTy;"},{y,6982,"/// Prepares for a scalar cast, performing all the necessary stages\n/// except the final cast and returning the kind required.\nCastKind Sema::PrepareScalarCast(ExprResult &Src, QualType DestTy) {\n  case Type::STK_IntegralComplex:\n    case Type::STK_FixedPoint:\n      Diag(Src.get()->getExprLoc(), diag::err_unimplemented_conversion_with_fixed_point_type) << SrcTy;"}}

[j]={{z,12738,"void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *CopyAssignOperator) {\n  // Assign non-static members.\n  for (auto *Field : ClassDecl->fields()) {\n    // Check for members of reference type; we can\'t copy those.\n    if (Field->getType()->isReferenceType()) {\n      Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();"},{z,12747,"void Sema::DefineImplicitCopyAssignment(SourceLocation CurrentLocation, CXXMethodDecl *CopyAssignOperator) {\n  // Assign non-static members.\n  for (auto *Field : ClassDecl->fields()) {\n    if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {\n      Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();"},{z,13067,"void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MoveAssignOperator) {\n  // Assign non-static members.\n  for (auto *Field : ClassDecl->fields()) {\n    // Check for members of reference type; we can\'t move those.\n    if (Field->getType()->isReferenceType()) {\n      Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) << Context.getTagDeclType(ClassDecl) << 0 << Field->getDeclName();"},{z,13076,"void Sema::DefineImplicitMoveAssignment(SourceLocation CurrentLocation, CXXMethodDecl *MoveAssignOperator) {\n  // Assign non-static members.\n  for (auto *Field : ClassDecl->fields()) {\n    if (!BaseType->getAs<RecordType>() && BaseType.isConstQualified()) {\n      Diag(ClassDecl->getLocation(), diag::err_uninitialized_member_for_assign) << Context.getTagDeclType(ClassDecl) << 1 << Field->getDeclName();"}}

[j]={{z,4254,"static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit) {\n  if (!Field->getParent()->isUnion()) {\n    if (FieldBaseElementType->isReferenceType()) {\n      SemaRef.Diag(Constructor->getLocation(), diag::err_uninitialized_member_in_ctor) << (int)Constructor->isImplicit() << SemaRef.Context.getTagDeclType(Constructor->getParent()) << 0 << Field->getDeclName();"},{z,4260,"static bool BuildImplicitMemberInitializer(Sema &SemaRef, CXXConstructorDecl *Constructor, ImplicitInitializerKind ImplicitInitKind, FieldDecl *Field, IndirectFieldDecl *Indirect, CXXCtorInitializer *&CXXMemberInit) {\n  if (!Field->getParent()->isUnion()) {\n    if (FieldBaseElementType.isConstQualified()) {\n      SemaRef.Diag(Constructor->getLocation(), diag::err_uninitialized_member_in_ctor) << (int)Constructor->isImplicit() << SemaRef.Context.getTagDeclType(Constructor->getParent()) << 1 << Field->getDeclName();"},{T,8384,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_DefaultInitOfConst:\n    if (Entity.getKind() == InitializedEntity::EK_Member && isa<CXXConstructorDecl>(S.CurContext)) {\n      S.Diag(Kind.getLocation(), diag::err_uninitialized_member_in_ctor) << (Constructor->getInheritedConstructor() ? 2 : Constructor->isImplicit() ? 1 : 0) << S.Context.getTypeDeclType(Constructor->getParent()) << /*const=*/1 << Entity.getName();"}}

[j]={{z,2307,"/// Check the validity of a C++ base class specifier.\n///\n/// \\returns a new CXXBaseSpecifier if well-formed, emits diagnostics\n/// and returns NULL otherwise.\nCXXBaseSpecifier *Sema::CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc) {\n  // C++ [class.union]p1:\n  //  A union shall not be used as a base class.\n  if (BaseType->isUnionType()) {\n    Diag(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;"}}

[j]={{w,15961,"/// Build a new FieldDecl and check its well-formedness.\n///\n/// This routine builds a new FieldDecl given the fields name, type,\n/// record, etc. \\p PrevDecl should refer to any previous declaration\n/// with the same name and in the same scope as the field to be\n/// created.\n///\n/// \\returns a new FieldDecl.\n///\n/// \\todo The Declarator argument is a hack. It will be removed once\nFieldDecl *Sema::CheckFieldDecl(DeclarationName Name, QualType T, TypeSourceInfo *TInfo, RecordDecl *Record, SourceLocation Loc, bool Mutable, Expr *BitWidth, InClassInitStyle InitStyle, SourceLocation TSSL, AccessSpecifier AS, NamedDecl *PrevDecl, Declarator *D) {\n  if (!InvalidDecl && getLangOpts().CPlusPlus) {\n    if (Record->isUnion()) {\n      // C++ [class.union]p1: If a union contains a member of reference type,\n      // the program is ill-formed, except when compiling with MSVC extensions\n      // enabled.\n      if (EltTy->isReferenceType()) {\n        Diag(NewFD->getLocation(), getLangOpts().MicrosoftExt ? diag::ext_union_member_of_reference_type : diag::err_union_member_of_reference_type) << NewFD->getDeclName() << EltTy;"}}

[j]={{"clang/lib/Frontend/CompilerInvocation.cpp",941,"#include \"clang/StaticAnalyzer/Core/AnalyzerOptions.def\"\n  // FIXME: Here we try to validate the silenced checkers or packages are valid.\n  // The current approach only validates the registered checkers which does not\n  // contain the runtime enabled checkers and optimally we would validate both.\n  if (!AnOpts.RawSilencedCheckersAndPackages.empty()) {\n    for (const StringRef &CheckerOrPackage : CheckersAndPackages) {\n      if (Diags) {\n        if (!IsValidName)\n          Diags->Report(diag::err_unknown_analyzer_checker_or_package) << CheckerOrPackage;"},{"clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp",153,"#endif\n  // Parse \'-analyzer-checker\' and \'-analyzer-disable-checker\' options from the\n  // command line.\n  for (const std::pair<std::string, bool> &Opt : AnOpts.CheckersAndPackages) {\n    if (CheckerForCmdLineArg.begin() == CheckerForCmdLineArg.end()) {\n      Diags.Report(diag::err_unknown_analyzer_checker_or_package) << Opt.first;"},{"clang/lib/StaticAnalyzer/Frontend/CheckerRegistry.cpp",412,"void CheckerRegistry::validateCheckerOptions() const {\n  for (const auto &Config : AnOpts.Config) {\n    Diags.Report(diag::err_unknown_analyzer_checker_or_package) << SuppliedCheckerOrPackage;"}}

[j]={{y,18357,"/// A visitor for rebuilding an expression of type __unknown_anytype\n/// into one which resolves the type directly on the referring\n/// expression.  Strict preservation of the original source\n/// structure is not a goal.\nstruct RebuildUnknownAnyExpr : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {\n  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {\n    if (!Ptr) {\n      S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof) << E->getSourceRange();"}}

[j]={{y,18362,"/// A visitor for rebuilding an expression of type __unknown_anytype\n/// into one which resolves the type directly on the referring\n/// expression.  Strict preservation of the original source\n/// structure is not a goal.\nstruct RebuildUnknownAnyExpr : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {\n  ExprResult VisitUnaryAddrOf(UnaryOperator *E) {\n    if (isa<CallExpr>(E->getSubExpr())) {\n      S.Diag(E->getOperatorLoc(), diag::err_unknown_any_addrof_call) << E->getSourceRange();"}}

[j]={{y,18562,"ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {\n  //  - functions\n  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {\n    if (!Type->isFunctionType()) {\n      S.Diag(E->getExprLoc(), diag::err_unknown_any_function) << VD << E->getSourceRange();"}}

[j]={{y,18608,"ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {\n  //  - functions\n  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {\n  } else if (isa<VarDecl>(VD)) {\n    if (const ReferenceType *RefTy = Type->getAs<ReferenceType>()) {\n    } else if (Type->isFunctionType()) {\n      S.Diag(E->getExprLoc(), diag::err_unknown_any_var_function_type) << VD << E->getSourceRange();"}}

[j]={{"clang/lib/Parse/ParseHLSL.cpp",170,"void Parser::ParseHLSLSemantics(ParsedAttributes &Attrs, SourceLocation *EndLoc) {\n  case ParsedAttr::UnknownAttribute:\n    Diag(Loc, diag::err_unknown_hlsl_semantic) << II;"}}

[j]={{w,681,"void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName) {\n  if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS, CCC, CTK_ErrorRecovery)) {\n    if (Corrected.isKeyword()) {\n    } else {\n      // We found a similarly-named type or interface; suggest that.\n      if (!SS || !SS->isSet()) {\n      } else if (DeclContext *DC = computeDeclContext(*SS, false)) {\n        diagnoseTypo(Corrected, PDiag(IsTemplateName ? diag::err_no_member_template_suggest : diag::err_unknown_nested_typename_suggest) << II << DC << DroppedSpecifier << SS->getRange(), CanRecover);"},{w,899,"Corrected:\n  case LookupResult::NotFound:\n    // Perform typo correction to determine if there is another name that is\n    // close to this name.\n    if (!SecondTry && CCC) {\n      if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S, &SS, *CCC, CTK_ErrorRecovery)) {\n        if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {\n        } else if (UnderlyingFirstDecl && (isa<TypeDecl>(UnderlyingFirstDecl) || isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {\n          QualifiedDiag = diag::err_unknown_nested_typename_suggest;"}}

[j]={{Zb,1912,"Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S, IdentifierInfo *Name, SourceLocation NameLoc, bool IsSuper, bool HasTrailingDot, ParsedType &ReceiverType) {\n  if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S, nullptr, CCC, CTK_ErrorRecovery, nullptr, false, nullptr, false)) {\n    if (Corrected.isKeyword()) {\n      diagnoseTypo(Corrected, PDiag(diag::err_unknown_receiver_suggest) << Name);"},{Zb,1917,"Sema::ObjCMessageKind Sema::getObjCMessageKind(Scope *S, IdentifierInfo *Name, SourceLocation NameLoc, bool IsSuper, bool HasTrailingDot, ParsedType &ReceiverType) {\n  if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S, nullptr, CCC, CTK_ErrorRecovery, nullptr, false, nullptr, false)) {\n    if (Corrected.isKeyword()) {\n    } else if (ObjCInterfaceDecl *Class = Corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {\n      diagnoseTypo(Corrected, PDiag(diag::err_unknown_receiver_suggest) << Name);"}}

[j]={{L,1164,"/// ParseBaseTypeSpecifier - Parse a C++ base-type-specifier which is either a\n/// class name or decltype-specifier. Note that we only check that the result\n/// names a type; semantic analysis will need to verify that the type names a\n/// class. The result is either a type or null, depending on whether a type\n/// name was found.\n///\n///      base-type-specifier: [C++11 class.derived]\n///        class-or-decltype\n///      class-or-decltype: [C++11 class.derived]\n///        nested-name-specifier[opt] class-name\n///        decltype-specifier\n///      class-name: [C++ class.name]\n///        identifier\n///        simple-template-id\n///\n/// In C++98, instead of base-type-specifier, we have:\n///\n///        ::[opt] nested-name-specifier[opt] class-name\nTypeResult Parser::ParseBaseTypeSpecifier(SourceLocation &BaseLoc, SourceLocation &EndLocation) {\n  if (Tok.is(tok::less)) {\n    if (!Actions.DiagnoseUnknownTemplateName(*Id, IdLoc, getCurScope(), &SS, Template, TNK)) {\n      Diag(IdLoc, diag::err_unknown_template_name) << Id;"}}

[j]={{w,415,"/// If the identifier refers to a type name within this scope,\n/// return the declaration of that type.\n///\n/// This routine performs ordinary name lookup of the identifier II\n/// within the given scope, with optional C++ scope specifier SS, to\n/// determine whether the name refers to a type. If so, returns an\n/// opaque pointer (actually a QualType) corresponding to that\n/// type. Otherwise, returns NULL.\nParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS, bool isClassName, bool HasTrailingDot, ParsedType ObjectTypePtr, bool IsCtorOrDtorName, bool WantNontrivialTypeSourceInfo, bool IsClassTemplateDeductionContext, ImplicitTypenameContext AllowImplicitTypename, IdentifierInfo **CorrectedII) {\n  case LookupResult::NotFoundInCurrentInstantiation:\n    if (CorrectedII) {\n      if (Correction && (NNS || NewII != &II) &&\n        if (Ty) {\n          diagnoseTypo(Correction, PDiag(diag::err_unknown_type_or_class_name_suggest) << Result.getLookupName() << isClassName);"},{ob,1400,"void Sema::actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef<IdentifierInfo *> identifiers, ArrayRef<SourceLocation> identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols) {\n  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {\n    if (corrected) {\n      // Did we find an Objective-C class?\n      if (auto objcClass = corrected.getCorrectionDeclAs<ObjCInterfaceDecl>()) {\n        diagnoseTypo(corrected, PDiag(diag::err_unknown_type_or_class_name_suggest) << identifiers[i] << true);"}}

[j]={{w,717,"void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName) {\n  if (!SS || (!SS->isSet() && !SS->isInvalid()))\n    Diag(IILoc, IsTemplateName ? diag::err_no_template : diag::err_unknown_typename) << II;"},{z,10409,"Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation IdentLoc, IdentifierInfo &II, CXXScopeSpec *SS) {\n  if (EnumTy.isNull()) {\n    Diag(IdentLoc, SS && isDependentScopeSpecifier(*SS) ? diag::err_using_enum_is_dependent : diag::err_unknown_typename) << II.getName() << SourceRange(SS ? SS->getBeginLoc() : IdentLoc, IdentLoc);"},{ob,1409,"void Sema::actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef<IdentifierInfo *> identifiers, ArrayRef<SourceLocation> identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols) {\n  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {\n    Diag(identifierLocs[i], (lookupKind == LookupAnyName ? diag::err_objc_type_arg_missing : lookupKind == LookupObjCProtocolName ? diag::err_undeclared_protocol : diag::err_unknown_typename)) << identifiers[i];"},{E,9090,"/// Build the type that describes a C++ typename specifier,\n/// e.g., \"typename T::type\".\nQualType Sema::CheckTypenameType(ElaboratedTypeKeyword Keyword, SourceLocation KeywordLoc, NestedNameSpecifierLoc QualifierLoc, const IdentifierInfo &II, SourceLocation IILoc, bool DeducedTSTContext) {\n  case LookupResult::NotFound: {\n    DiagID = Ctx ? diag::err_typename_nested_not_found : diag::err_unknown_typename;"}}

[j]={{w,672,"void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName) {\n  if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS, CCC, CTK_ErrorRecovery)) {\n    if (Corrected.isKeyword()) {\n      diagnoseTypo(Corrected, PDiag(IsTemplateName ? diag::err_no_template_suggest : diag::err_unknown_typename_suggest) << II);"},{w,677,"void Sema::DiagnoseUnknownTypeName(IdentifierInfo *&II, SourceLocation IILoc, Scope *S, CXXScopeSpec *SS, ParsedType &SuggestedType, bool IsTemplateName) {\n  if (TypoCorrection Corrected = CorrectTypo(DeclarationNameInfo(II, IILoc), LookupOrdinaryName, S, SS, CCC, CTK_ErrorRecovery)) {\n    if (Corrected.isKeyword()) {\n    } else {\n      // We found a similarly-named type or interface; suggest that.\n      if (!SS || !SS->isSet()) {\n        diagnoseTypo(Corrected, PDiag(IsTemplateName ? diag::err_no_template_suggest : diag::err_unknown_typename_suggest) << II, CanRecover);"},{w,898,"Corrected:\n  case LookupResult::NotFound:\n    // Perform typo correction to determine if there is another name that is\n    // close to this name.\n    if (!SecondTry && CCC) {\n      if (TypoCorrection Corrected = CorrectTypo(Result.getLookupNameInfo(), Result.getLookupKind(), S, &SS, *CCC, CTK_ErrorRecovery)) {\n        if (getLangOpts().CPlusPlus && NextToken.is(tok::less) && UnderlyingFirstDecl && isa<TemplateDecl>(UnderlyingFirstDecl)) {\n        } else if (UnderlyingFirstDecl && (isa<TypeDecl>(UnderlyingFirstDecl) || isa<ObjCInterfaceDecl>(UnderlyingFirstDecl) || isa<ObjCCompatibleAliasDecl>(UnderlyingFirstDecl))) {\n          UnqualifiedDiag = diag::err_unknown_typename_suggest;"},{ob,1391,"void Sema::actOnObjCTypeArgsOrProtocolQualifiers(Scope *S, ParsedType baseType, SourceLocation lAngleLoc, ArrayRef<IdentifierInfo *> identifiers, ArrayRef<SourceLocation> identifierLocs, SourceLocation rAngleLoc, SourceLocation &typeArgsLAngleLoc, SmallVectorImpl<ParsedType> &typeArgs, SourceLocation &typeArgsRAngleLoc, SourceLocation &protocolLAngleLoc, SmallVectorImpl<Decl *> &protocols, SourceLocation &protocolRAngleLoc, bool warnOnIncompleteProtocols) {\n  for (unsigned i = 0, n = identifiers.size(); i != n; ++i) {\n    if (corrected) {\n      // Did we find a type?\n      if (auto typeDecl = corrected.getCorrectionDeclAs<TypeDecl>()) {\n        diagnoseTypo(corrected, PDiag(diag::err_unknown_typename_suggest) << identifiers[i]);"}}

[j]={{ub,257,"/// \\brief Parse a constraint-logical-and-expression.\n///\n/// \\verbatim\n///      C++2a[temp.constr.decl]p1\n///      constraint-logical-and-expression:\n///        primary-expression\n///        constraint-logical-and-expression \'&&\' primary-expression\n///\n/// \\endverbatim\nExprResult Parser::ParseConstraintLogicalAndExpression(bool IsTrailingRequiresClause) {\n  auto ParsePrimary = [&]() {\n    auto RecoverFromNonPrimary = [&](ExprResult E, bool Note) {\n      if (!E.isInvalid())\n        Diag(E.get()->getExprLoc(), Note ? diag::note_unparenthesized_non_primary_expr_in_requires_clause : diag::err_unparenthesized_non_primary_expr_in_requires_clause) << FixItHint::CreateInsertion(E.get()->getBeginLoc(), \"(\") << FixItHint::CreateInsertion(PP.getLocForEndOfToken(E.get()->getEndLoc()), \")\") << E.get()->getSourceRange();"}}

[j]={{y,12904,"/// CheckAddressOfOperand - The operand of & must be either a function\n/// designator or an lvalue designating an object. If it is an lvalue, the\n/// object cannot be declared with storage class register or be a bit field.\n/// Note: The usual conversions are *not* applied to the operand of the &\n/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.\n/// In C++, the operand might be an overloaded function name, in which case\n/// we allow the \'&\' but retain the overloaded-function type.\nQualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {\n  if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {\n  } else if (isa<ObjCSelectorExpr>(op)) {\n  } else if (lval == Expr::LV_MemberFunction) {\n    // The id-expression was parenthesized.\n    if (OrigOp.get() != DRE) {\n    } else if (!DRE->getQualifier()) {\n      if (MD->getParent()->getName().empty())\n        Diag(OpLoc, diag::err_unqualified_pointer_member_function) << op->getSourceRange();"},{y,12908,"/// CheckAddressOfOperand - The operand of & must be either a function\n/// designator or an lvalue designating an object. If it is an lvalue, the\n/// object cannot be declared with storage class register or be a bit field.\n/// Note: The usual conversions are *not* applied to the operand of the &\n/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.\n/// In C++, the operand might be an overloaded function name, in which case\n/// we allow the \'&\' but retain the overloaded-function type.\nQualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {\n  if (lval == Expr::LV_ClassTemporary || lval == Expr::LV_ArrayTemporary) {\n  } else if (isa<ObjCSelectorExpr>(op)) {\n  } else if (lval == Expr::LV_MemberFunction) {\n    // The id-expression was parenthesized.\n    if (OrigOp.get() != DRE) {\n    } else if (!DRE->getQualifier()) {\n      if (MD->getParent()->getName().empty())\n      else {\n        Diag(OpLoc, diag::err_unqualified_pointer_member_function) << op->getSourceRange() << FixItHint::CreateInsertion(op->getSourceRange().getBegin(), Qual);"}}

[j]={{F,6876,"/// [C90]  direct-declarator \'[\' constant-expression[opt] \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list[opt] assignment-expr[opt] \']\'\n/// [C99]  direct-declarator \'[\' \'static\' type-qual-list[opt] assign-expr \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list \'static\' assignment-expr \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list[opt] \'*\' \']\'\n/// [C++11] direct-declarator \'[\' constant-expression[opt] \']\'\n///                          attribute-specifier-seq[opt]\nvoid Parser::ParseBracketDeclarator(Declarator &D) {\n  // Handle the case where we have \'[*]\' as the array size.  However, a leading\n  // star could be the start of an expression, for example \'X[*p + 4]\'.  Verify\n  // the token after the star is a \']\'.  Since stars in arrays are\n  // infrequent, use of lookahead is not costly here.\n  if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {\n  } else if (Tok.isNot(tok::r_square)) {\n  } else {\n    if (StaticLoc.isValid()) {\n      Diag(StaticLoc, diag::err_unspecified_size_with_static);"}}

[j]={{F,6856,"/// [C90]  direct-declarator \'[\' constant-expression[opt] \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list[opt] assignment-expr[opt] \']\'\n/// [C99]  direct-declarator \'[\' \'static\' type-qual-list[opt] assign-expr \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list \'static\' assignment-expr \']\'\n/// [C99]  direct-declarator \'[\' type-qual-list[opt] \'*\' \']\'\n/// [C++11] direct-declarator \'[\' constant-expression[opt] \']\'\n///                          attribute-specifier-seq[opt]\nvoid Parser::ParseBracketDeclarator(Declarator &D) {\n  // Handle the case where we have \'[*]\' as the array size.  However, a leading\n  // star could be the start of an expression, for example \'X[*p + 4]\'.  Verify\n  // the token after the star is a \']\'.  Since stars in arrays are\n  // infrequent, use of lookahead is not costly here.\n  if (Tok.is(tok::star) && GetLookAheadToken(1).is(tok::r_square)) {\n    if (StaticLoc.isValid()) {\n      Diag(StaticLoc, diag::err_unspecified_vla_size_with_static);"}}

[j]={{"clang/lib/Basic/Targets/Mips.cpp",200,"bool MipsTargetInfo::validateTarget(DiagnosticsEngine &Diags) const {\n  // -fpxx is valid only for the o32 ABI\n  if (FPMode == FPXX && (ABI == \"n32\" || ABI == \"n64\")) {\n    Diags.Report(diag::err_unsupported_abi_for_opt) << \"-mfpxx\""}}

[j]={{jc,918,"ExpectedType ASTNodeImporter::VisitType(const Type *T) {\n  Importer.FromDiag(SourceLocation(), diag::err_unsupported_ast_node) << T->getTypeClassName();"},{jc,1497,"//----------------------------------------------------------------------------\n// Import Declarations\n//----------------------------------------------------------------------------\nError ASTNodeImporter::ImportDeclParts(NamedDecl *D, DeclContext *&DC, DeclContext *&LexicalDC, DeclarationName &Name, NamedDecl *&ToD, SourceLocation &Loc) {\n  if (isa<RecordDecl>(D) && (FunDecl = dyn_cast<FunctionDecl>(OrigDC)) && FunDecl->hasBody()) {\n    for (const ParmVarDecl *P : FunDecl->parameters()) {\n      if (RT && RT->getDecl() == D) {\n        Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) << D->getDeclKindName();"},{jc,1995,"ExpectedDecl ASTNodeImporter::VisitDecl(Decl *D) {\n  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) << D->getDeclKindName();"},{jc,2000,"ExpectedDecl ASTNodeImporter::VisitImportDecl(ImportDecl *D) {\n  Importer.FromDiag(D->getLocation(), diag::err_unsupported_ast_node) << D->getDeclKindName();"},{jc,5719,"ExpectedStmt ASTNodeImporter::VisitStmt(Stmt *S) {\n  Importer.FromDiag(S->getBeginLoc(), diag::err_unsupported_ast_node) << S->getStmtClassName();"},{jc,6174,"//----------------------------------------------------------------------------\n// Import Expressions\n//----------------------------------------------------------------------------\nExpectedStmt ASTNodeImporter::VisitExpr(Expr *E) {\n  Importer.FromDiag(E->getBeginLoc(), diag::err_unsupported_ast_node) << E->getStmtClassName();"}}

[j]={{"clang/lib/Basic/SourceManager.cpp",151,"std::optional<llvm::MemoryBufferRef> ContentCache::getBufferOrNone(DiagnosticsEngine &Diag, FileManager &FM, SourceLocation Loc) const {\n  if (InvalidBOM) {\n    Diag.Report(Loc, diag::err_unsupported_bom) << InvalidBOM << ContentsEntry->getName();"}}

[j]={{"clang/lib/Frontend/CompilerInvocation.cpp",3374,"#include \"clang/Driver/Options.inc\"\n  if (!CXXABI.empty()) {\n    if (!TargetCXXABI::isABI(CXXABI)) {\n    } else {\n      if (!TargetCXXABI::isSupportedCXXABI(T, Kind))\n        Diags.Report(diag::err_unsupported_cxx_abi) << CXXABI << T.str();"}}

[j]={{wb,2210,"/// 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  if (Tok.is(tok::colon)) {\n    if (!getLangOpts().CPlusPlusModules)\n      Diag(ColonLoc, diag::err_unsupported_module_partition) << SourceRange(ColonLoc, Partition.back().second);"},{wb,2269,"/// Parse a module import declaration. This is essentially the same for\n/// Objective-C and C++20 except for the leading \'@\' (in ObjC) and the\n/// trailing optional attributes (in C++).\n///\n/// [ObjC]  @import declaration:\n///          \'@\' \'import\' module-name \';\'\n/// [ModTS] module-import-declaration:\n///          \'import\' module-name attribute-specifier-seq[opt] \';\'\n/// [C++20] module-import-declaration:\n///          \'export\'[opt] \'import\' module-name\n///                  attribute-specifier-seq[opt] \';\'\n///          \'export\'[opt] \'import\' module-partition\n///                  attribute-specifier-seq[opt] \';\'\n///          \'export\'[opt] \'import\' header-name\n///                  attribute-specifier-seq[opt] \';\'\nDecl *Parser::ParseModuleImport(SourceLocation AtLoc, Sema::ModuleImportState &ImportState) {\n  if (Tok.is(tok::header_name)) {\n  } else if (Tok.is(tok::annot_header_unit)) {\n  } else if (Tok.is(tok::colon)) {\n    if (!getLangOpts().CPlusPlusModules)\n      Diag(ColonLoc, diag::err_unsupported_module_partition) << SourceRange(ColonLoc, Path.back().second);"}}

[j]={{E,1053,"bool Sema::AttachTypeConstraint(AutoTypeLoc TL, NonTypeTemplateParmDecl *NewConstrainedParm, NonTypeTemplateParmDecl *OrigConstrainedParm, SourceLocation EllipsisLoc) {\n  if (NewConstrainedParm->getType() != TL.getType() || TL.getAutoKeyword() != AutoTypeKeyword::Auto) {\n    Diag(NewConstrainedParm->getTypeSourceInfo()->getTypeLoc().getBeginLoc(), diag::err_unsupported_placeholder_constraint) << NewConstrainedParm->getTypeSourceInfo()->getTypeLoc().getSourceRange();"}}

[j]={{cb,1770,"void StringLiteralParser::init(ArrayRef<Token> StringToks) {\n  /// (C99 5.1.1.2p1).  The common case is only one string fragment.\n  for (const Token &Tok : StringToks) {\n    // Remember if we see any wide or utf-8/16/32 strings.\n    // Also check for illegal concatenations.\n    if (isUnevaluated() && Tok.getKind() != tok::string_literal) {\n    } else if (Tok.isNot(Kind) && Tok.isNot(tok::string_literal)) {\n      if (isOrdinary()) {\n      } else {\n        if (Diags)\n          Diags->Report(Tok.getLocation(), diag::err_unsupported_string_concat);"}}

[j]={{y,18248,"/// A visitor for rebuilding a call to an __unknown_any expression\n/// to have an appropriate type.\nstruct RebuildUnknownAnyFunction : StmtVisitor<RebuildUnknownAnyFunction, ExprResult> {\n  ExprResult VisitExpr(Expr *E) {\n    S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_call) << E->getSourceRange();"}}

[j]={{y,18614,"ExprResult RebuildUnknownAnyExpr::resolveDecl(Expr *E, ValueDecl *VD) {\n  //  - functions\n  if (FunctionDecl *FD = dyn_cast<FunctionDecl>(VD)) {\n  } else if (isa<VarDecl>(VD)) {\n  } else {\n    S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_decl) << VD << E->getSourceRange();"}}

[j]={{y,18329,"/// A visitor for rebuilding an expression of type __unknown_anytype\n/// into one which resolves the type directly on the referring\n/// expression.  Strict preservation of the original source\n/// structure is not a goal.\nstruct RebuildUnknownAnyExpr : StmtVisitor<RebuildUnknownAnyExpr, ExprResult> {\n  ExprResult VisitExpr(Expr *E) {\n    S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr) << E->getSourceRange();"},{y,18699,"static ExprResult diagnoseUnknownAnyExpr(Sema &S, Expr *E) {\n  if (DeclRefExpr *ref = dyn_cast<DeclRefExpr>(E)) {\n  } else if (MemberExpr *mem = dyn_cast<MemberExpr>(E)) {\n  } else if (ObjCMessageExpr *msg = dyn_cast<ObjCMessageExpr>(E)) {\n  } else {\n    S.Diag(E->getExprLoc(), diag::err_unsupported_unknown_any_expr) << E->getSourceRange();"}}

[j]={{"clang/lib/Lex/PPMacroExpansion.cpp",766,"/// ReadFunctionLikeMacroArgs - After reading \"MACRO\" and knowing that the next\n/// token is the \'(\' of the macro, this method is invoked to read all of the\n/// actual arguments specified for the macro invocation.  This returns null on\n/// error.\nMacroArgs *Preprocessor::ReadMacroCallArgumentList(Token &MacroName, MacroInfo *MI, SourceLocation &MacroEnd) {\n  while (Tok.isNot(tok::r_paren)) {\n    while (true) {\n      if (Tok.isOneOf(tok::eof, tok::eod)) { // \"#if f(<eof>\" & \"#if f(\\n\"\n        if (!ContainsCodeCompletionTok) {\n          Diag(MacroName, diag::err_unterm_macro_invoc);"},{"clang/lib/Lex/PPMacroExpansion.cpp",1232,"/// 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::eod:\n      PP.Diag(Tok.getLocation(), diag::err_unterm_macro_invoc);"}}

[j]={{lb,370,"/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text\n/// is not enclosed within a string literal.\nvoid Preprocessor::HandleMicrosoft__pragma(Token &Tok) {\n  if (Tok.is(tok::eof)) {\n    Diag(PragmaLoc, diag::err_unterminated___pragma);"}}

[j]={{Z,2509,"/// We have just read from input the / and * characters that started a comment.\n/// Read until we find the * and / characters that terminate the comment.\n/// Note that we don\'t bother decoding trigraphs or escaped newlines in block\n/// comments, because they cannot cause the comment to end.  The only thing\n/// that can happen is the comment could end with an escaped newline between\n/// the terminating * and /.\n///\n/// If we\'re in KeepCommentMode or any CommentHandler has inserted\n/// some tokens, this will store the first token and return true.\nbool Lexer::SkipBlockComment(Token &Result, const char *CurPtr, bool &TokAtPhysicalStartOfLine) {\n  if (C == 0 && CurPtr == BufferEnd + 1) {\n    if (!isLexingRawMode())\n      Diag(BufferPtr, diag::err_unterminated_block_comment);"},{Z,2647,"#endif\n    FoundSlash:\n    } else if (C == 0 && CurPtr == BufferEnd + 1) {\n      if (!isLexingRawMode())\n        Diag(BufferPtr, diag::err_unterminated_block_comment);"}}

[j]={{Z,1994,"/// 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  while (true) {\n    if (C == \')\') {\n    } else if (C == 0 && CurPtr - 1 == BufferEnd) { // End of file.\n      if (!isLexingRawMode())\n        Diag(BufferPtr, diag::err_unterminated_raw_string) << StringRef(Prefix, PrefixLen);"}}

[j]={{Ab,1567,"/// TryStaticMemberPointerUpcast - Tests whether a conversion according to\n/// C++ 5.2.9p9 is valid:\n///\n///  An rvalue of type \"pointer to member of D of type cv1 T\" can be\n///  converted to an rvalue of type \"pointer to member of B of type cv2 T\",\n///  where B is a base class of D [...].\n///\nTryCastResult TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, QualType DestType, bool CStyle, SourceRange OpRange, unsigned &msg, CastKind &Kind, CXXCastPath &BasePath) {\n  if (!CStyle) {\n    switch (Self.CheckBaseClassAccess(OpRange.getBegin(), DestClass, SrcClass, Paths.front(), diag::err_upcast_to_inaccessible_base)) {"},{z,2697,"bool Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, SourceLocation Loc, SourceRange Range, CXXCastPath *BasePath, bool IgnoreAccess) { return CheckDerivedToBaseConversion(Derived, Base, diag::err_upcast_to_inaccessible_base, diag::err_ambiguous_derived_to_base_conv, Loc, Range, DeclarationName(), BasePath, IgnoreAccess); }"},{Jb,2693,"/// CheckPointerConversion - Check the pointer conversion from the\n/// expression From to the type ToType. This routine checks for\n/// ambiguous or inaccessible derived-to-base pointer\n/// conversions for which IsPointerConversion has already returned\n/// true. It returns true and produces a diagnostic if there was an\n/// error, or returns false otherwise.\nbool Sema::CheckPointerConversion(Expr *From, QualType ToType, CastKind &Kind, CXXCastPath &BasePath, bool IgnoreBaseAccess, bool Diagnose) {\n  if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {\n    if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {\n      if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {\n        if (Diagnose) {\n          InaccessibleID = diag::err_upcast_to_inaccessible_base;"}}

[j]={{Cc,387,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // Check for consistency with the previous declaration, if there is one.\n  if (PIDecl) {\n    // A readonly property declared in the primary class can be refined\n    // by adding a readwrite property within an extension.\n    // Anything else is an error.\n    if (!(PIDecl->isReadOnly() && isReadWrite)) {\n      unsigned diag = (Attributes & ObjCPropertyAttribute::kind_readwrite) && (PIDecl->getPropertyAttributesAsWritten() & ObjCPropertyAttribute::kind_readwrite) ? diag::err_use_continuation_class_redeclaration_readwrite : diag::err_use_continuation_class;"}}

[j]={{Cc,387,"ObjCPropertyDecl *Sema::HandlePropertyInClassExtension(Scope *S, SourceLocation AtLoc, SourceLocation LParenLoc, FieldDeclarator &FD, Selector GetterSel, SourceLocation GetterNameLoc, Selector SetterSel, SourceLocation SetterNameLoc, const bool isReadWrite, unsigned &Attributes, const unsigned AttributesAsWritten, QualType T, TypeSourceInfo *TSI, tok::ObjCKeywordKind MethodImplKind) {\n  // Check for consistency with the previous declaration, if there is one.\n  if (PIDecl) {\n    // A readonly property declared in the primary class can be refined\n    // by adding a readwrite property within an extension.\n    // Anything else is an error.\n    if (!(PIDecl->isReadOnly() && isReadWrite)) {\n      unsigned diag = (Attributes & ObjCPropertyAttribute::kind_readwrite) && (PIDecl->getPropertyAttributesAsWritten() & ObjCPropertyAttribute::kind_readwrite) ? diag::err_use_continuation_class_redeclaration_readwrite : diag::err_use_continuation_class;"}}

[j]={{y,5243,"bool Sema::CheckCXXDefaultArgExpr(SourceLocation CallLoc, FunctionDecl *FD, ParmVarDecl *Param, Expr *RewrittenInit, bool SkipImmediateInvocations) {\n  if (Param->hasUnparsedDefaultArg()) {\n    Diag(CallLoc, diag::err_use_of_default_argument_to_function_declared_later) << FD << cast<CXXRecordDecl>(FD->getDeclContext());"}}

[j]={{y,332,"/// Determine whether the use of this declaration is valid, and\n/// emit any corresponding diagnostics.\n///\n/// This routine diagnoses various problems with referencing\n/// declarations that can occur when using a declaration. For example,\n/// it might warn if a deprecated or unavailable declaration is being\n/// used, or produce an error (and return true) if a C++0x deleted\n/// function is being used.\n///\n/// \\returns true if there was an error (this declaration cannot be\n/// referenced), false otherwise.\n///\nbool Sema::DiagnoseUseOfDecl(NamedDecl *D, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, bool ObjCPropertyAccess, bool AvoidPartialAvailabilityChecks, ObjCInterfaceDecl *ClassReceiver, bool SkipTrailingRequiresClause) {\n  if (const auto *EmptyD = dyn_cast<UnresolvedUsingIfExistsDecl>(D)) {\n    Diag(Loc, diag::err_use_of_empty_using_if_exists);"}}

[j]={{F,2574,"/// ParseImplicitInt - This method is called when we have an non-typename\n/// identifier in a declspec (which normally terminates the decl spec) when\n/// the declspec has no type specifier.  In this case, the declspec is either\n/// malformed or is \"implicit int\" (in K&R and C89).\n///\n/// This method handles diagnosing this prettily and returns false if the\n/// declspec is done being processed.  If it recovers and thinks there may be\n/// other pieces of declspec after it, it returns true.\n///\nbool Parser::ParseImplicitInt(DeclSpec &DS, CXXScopeSpec *SS, const ParsedTemplateInfo &TemplateInfo, AccessSpecifier AS, DeclSpecContext DSC, ParsedAttributes &Attrs) {\n  // Otherwise, if we don\'t consume this token, we are going to emit an\n  // error anyway.  Try to recover from various common problems.  Check\n  // to see if this was a reference to a tag name without a tag specified.\n  // This is a common problem in C (saying \'foo\' instead of \'struct foo\').\n  //\n  // C++ doesn\'t need this, and isTagName doesn\'t take SS.\n  if (SS == nullptr) {\n    if (TagName) {\n      Diag(Loc, diag::err_use_of_tag_name_without_tag) << TokenName << TagName << getLangOpts().CPlusPlus << FixItHint::CreateInsertion(Tok.getLocation(), FixitTagName);"},{w,778,"static bool isTagTypeWithMissingTag(Sema &SemaRef, LookupResult &Result, Scope *S, CXXScopeSpec &SS, IdentifierInfo *&Name, SourceLocation NameLoc) {\n  if (TagDecl *Tag = R.getAsSingle<TagDecl>()) {\n    SemaRef.Diag(NameLoc, diag::err_use_of_tag_name_without_tag) << Name << TagName << SemaRef.getLangOpts().CPlusPlus << FixItHint::CreateInsertion(NameLoc, FixItTagName);"}}

[j]={{y,18795,"/// Check for operands with placeholder types and complain if found.\n/// Returns ExprError() if there was an error and no recovery was possible.\nExprResult Sema::CheckPlaceholderExpr(Expr *E) {\n  case BuiltinType::BuiltinFn: {\n    if (DRE) {\n      if (Context.BuiltinInfo.isInStdNamespace(BuiltinID)) {\n        Diag(E->getBeginLoc(), getLangOpts().CPlusPlus20 ? diag::err_use_of_unaddressable_function : diag::warn_cxx20_compat_use_of_unaddressable_function);"}}

[j]={{w,15068,"/// 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        // Make sure that this wasn\'t declared as an enum and now used as a\n        // struct or something similar.\n        if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, TUK == TUK_Definition, KWLoc, Name)) {\n          if (SafeToContinue)\n            Diag(KWLoc, diag::err_use_with_wrong_tag) << Name << FixItHint::CreateReplacement(SourceRange(KWLoc), PrevTagDecl->getKindName());"},{w,15070,"/// 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        // Make sure that this wasn\'t declared as an enum and now used as a\n        // struct or something similar.\n        if (!isAcceptableTagRedeclaration(PrevTagDecl, Kind, TUK == TUK_Definition, KWLoc, Name)) {\n          if (SafeToContinue)\n          else\n            Diag(KWLoc, diag::err_use_with_wrong_tag) << Name;"},{E,1682,"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    if (!isAcceptableTagRedeclaration(PrevRecordDecl, Kind, TUK == TUK_Definition, KWLoc, Name)) {\n      Diag(KWLoc, diag::err_use_with_wrong_tag) << Name << FixItHint::CreateReplacement(KWLoc, PrevRecordDecl->getKindName());"},{E,3599,"TypeResult Sema::ActOnTagTemplateIdType(TagUseKind TUK, TypeSpecifierType TagSpec, SourceLocation TagLoc, CXXScopeSpec &SS, SourceLocation TemplateKWLoc, TemplateTy TemplateD, SourceLocation TemplateLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc) {\n  // Check the tag kind\n  if (const RecordType *RT = Result->getAs<RecordType>()) {\n    if (!isAcceptableTagRedeclaration(D, TagKind, TUK == TUK_Definition, TagLoc, Id)) {\n      Diag(TagLoc, diag::err_use_with_wrong_tag) << Result << FixItHint::CreateReplacement(SourceRange(TagLoc), D->getKindName());"},{E,7147,"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  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), Kind, TUK == TUK_Definition, KWLoc, ClassTemplate->getIdentifier())) {\n    Diag(KWLoc, diag::err_use_with_wrong_tag) << ClassTemplate << FixItHint::CreateReplacement(KWLoc, ClassTemplate->getTemplatedDecl()->getKindName());"},{E,8207,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n  if (!isAcceptableTagRedeclaration(ClassTemplate->getTemplatedDecl(), Kind, /*isDefinition*/ false, KWLoc, ClassTemplate->getIdentifier())) {\n    Diag(KWLoc, diag::err_use_with_wrong_tag) << ClassTemplate << FixItHint::CreateReplacement(KWLoc, ClassTemplate->getTemplatedDecl()->getKindName());"},{"clang/lib/Sema/SemaTemplateInstantiate.cpp",1231,"QualType TemplateInstantiator::RebuildElaboratedType(SourceLocation KeywordLoc, ElaboratedTypeKeyword Keyword, NestedNameSpecifierLoc QualifierLoc, QualType T) {\n  if (const TagType *TT = T->getAs<TagType>()) {\n    // TODO: should we even warn on struct/class mismatches for this?  Seems\n    // like it\'s likely to produce a lot of spurious errors.\n    if (Id && Keyword != ETK_None && Keyword != ETK_Typename) {\n      if (!SemaRef.isAcceptableTagRedeclaration(TD, Kind, /*isDefinition*/ false, TagLocation, Id)) {\n        SemaRef.Diag(TagLocation, diag::err_use_with_wrong_tag) << Id << FixItHint::CreateReplacement(SourceRange(TagLocation), TD->getKindName());"}}

[j]={{L,4006,"/// Parse a C++11 or C2x attribute-specifier.\n///\n/// [C++11] attribute-specifier:\n///        \'[\' \'[\' attribute-list \']\' \']\'\n///        alignment-specifier\n///\n/// [C++11] attribute-list:\n///        attribute[opt]\n///        attribute-list \',\' attribute[opt]\n///        attribute \'...\'\n///        attribute-list \',\' attribute \'...\'\n///\n/// [C++11] attribute:\n///        attribute-token attribute-argument-clause[opt]\n///\n/// [C++11] attribute-token:\n///        identifier\n///        attribute-scoped-token\n///\n/// [C++11] attribute-scoped-token:\n///        attribute-namespace \'::\' identifier\n///\n/// [C++11] attribute-namespace:\n///        identifier\nvoid Parser::ParseCXX11AttributeSpecifierInternal(ParsedAttributes &Attrs, CachedTokens &OpenMPTokens, SourceLocation *EndLoc) {\n  while (!Tok.isOneOf(tok::r_square, tok::semi, tok::eof)) {\n    if (CommonScopeName) {\n      if (ScopeName) {\n        Diag(ScopeLoc, diag::err_using_attribute_ns_conflict) << SourceRange(CommonScopeLoc);"}}

[j]={{z,11232,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  if (!CurContext->isRecord()) {\n    Diag(NameLoc, Cxx20Enumerator ? diag::warn_cxx17_compat_using_decl_class_member_enumerator : diag::err_using_decl_can_not_refer_to_class_member) << SS.getRange();"}}

[j]={{z,11012,"/// Builds a using declaration.\n///\n/// \\param IsInstantiation - Whether this call arises from an\n///  instantiation of an unresolved using declaration.  We treat\n///  the lookup differently for these declarations.\nNamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists) {\n  // C++14 [namespace.udecl]p6:\n  // A using-declaration shall not name a namespace.\n  if (R.getAsSingle<NamespaceDecl>()) {\n    Diag(IdentLoc, diag::err_using_decl_can_not_refer_to_namespace) << SS.getRange();"}}

[j]={{z,10552,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  // Always emit a diagnostic for a mismatch between an unresolved\n  // using_if_exists and a resolved using declaration in either direction.\n  if (isa<UnresolvedUsingIfExistsDecl>(Target) != (isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {\n    Diag(BUD->getLocation(), diag::err_using_decl_conflict);"},{z,10567,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  if (FunctionDecl *FD = Target->getAsFunction()) {\n    case Ovl_NonFunction:\n      Diag(BUD->getLocation(), diag::err_using_decl_conflict);"},{z,10579,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  if (FunctionDecl *FD = Target->getAsFunction()) {\n    // We found a decl with the exact signature.\n    case Ovl_Match:\n      Diag(BUD->getLocation(), diag::err_using_decl_conflict);"},{z,10596,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  if (isa<TagDecl>(Target)) {\n    Diag(BUD->getLocation(), diag::err_using_decl_conflict);"},{z,10607,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  Diag(BUD->getLocation(), diag::err_using_decl_conflict);"}}

[j]={{w,3195,"/// Check whether a redeclaration of an entity introduced by a\n/// using-declaration is valid, given that we know it\'s not an overload\n/// (nor a hidden tag declaration).\ntemplate <typename ExpectedDecl> static bool checkUsingShadowRedecl(Sema &S, UsingShadowDecl *OldS, ExpectedDecl *New) {\n  if (!Old) {\n    S.Diag(New->getLocation(), diag::err_using_decl_conflict_reverse);"},{w,15049,"/// 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 this is a redeclaration of a using shadow declaration, it must\n    // declare a tag in the same context. In MSVC mode, we allow a\n    // redefinition if either context is within the other.\n    if (auto *Shadow = dyn_cast<UsingShadowDecl>(DirectPrevDecl)) {\n      if (SS.isEmpty() && TUK != TUK_Reference && TUK != TUK_Friend && isDeclInScope(Shadow, SearchDC, S, isMemberSpecialization) && !(OldTag && isAcceptableTagRedeclContext(*this, OldTag->getDeclContext(), SearchDC))) {\n        Diag(KWLoc, diag::err_using_decl_conflict_reverse);"},{E,1659,"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 (auto *Shadow = dyn_cast_or_null<UsingShadowDecl>(PrevDecl ? Previous.getRepresentativeDecl() : nullptr)) {\n    if (SS.isEmpty() && !(PrevClassTemplate && PrevClassTemplate->getDeclContext()->getRedeclContext()->Equals(SemanticContext->getRedeclContext()))) {\n      Diag(KWLoc, diag::err_using_decl_conflict_reverse);"}}

[j]={{z,10353,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  case UnqualifiedIdKind::IK_ConstructorTemplateId:\n    Diag(Name.getBeginLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_using_decl_constructor : diag::err_using_decl_constructor) << SS.getRange();"}}

[j]={{z,11104,"/// Additional checks for a using declaration referring to a constructor name.\nbool Sema::CheckInheritingConstructorUsingDecl(UsingDecl *UD) {\n  if (!Base && !AnyDependentBases) {\n    Diag(UD->getUsingLoc(), diag::err_using_decl_constructor_not_in_direct_base) << UD->getNameInfo().getSourceRange() << QualType(SourceType, 0) << TargetClass;"}}

[j]={{z,10361,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  case UnqualifiedIdKind::IK_DestructorName:\n    Diag(Name.getBeginLoc(), diag::err_using_decl_destructor) << SS.getRange();"}}

[j]={{w,3273,"/// 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      if (New->getFriendObjectKind()) {\n        Diag(New->getLocation(), diag::err_using_decl_friend);"}}

[j]={{z,10487,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  // Diagnose finding a decl which is not from a base class of the\n  // current class.  We do this now because there are cases where this\n  // function will silently decide not to build a shadow decl, which\n  // will pre-empt further diagnostics.\n  //\n  // We don\'t need to do this in C++11 because we do the check once on\n  // the qualifier.\n  //\n  // FIXME: diagnose the following if we care enough:\n  //  struct A { int foo; };\n  //  struct B : A { using A::foo; };\n  //  template <class T> struct C : A {};\n  //  template <class T> struct D : C<T> { using B::foo; } // <---\n  // This is invalid (during instantiation) in C++03 because B::foo\n  // resolves to the using decl in B, which is not a base class of D<T>.\n  // We can\'t diagnose it immediately because C<T> is an unknown\n  // specialization. The UsingShadowDecl in D<T> then points directly\n  // to A::foo, which will look well-formed when we instantiate.\n  // The right solution is to not collapse the shadow-decl chain.\n  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord())\n    if (auto *Using = dyn_cast<UsingDecl>(BUD)) {\n      if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {\n        if (OrigDC == CurContext) {\n          Diag(Using->getLocation(), diag::err_using_decl_nested_name_specifier_is_current_class) << Using->getQualifierLoc().getSourceRange();"},{z,11324,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  if (getLangOpts().CPlusPlus11) {\n    if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(cast<CXXRecordDecl>(NamedContext))) {\n      if (CurContext == NamedContext) {\n        Diag(SS.getBeginLoc(), diag::err_using_decl_nested_name_specifier_is_current_class) << SS.getRange();"}}

[j]={{z,10493,"/// Determines whether to create a using shadow decl for a particular\n/// decl, given the set of decls existing prior to this using lookup.\nbool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig, const LookupResult &Previous, UsingShadowDecl *&PrevShadow) {\n  // Diagnose finding a decl which is not from a base class of the\n  // current class.  We do this now because there are cases where this\n  // function will silently decide not to build a shadow decl, which\n  // will pre-empt further diagnostics.\n  //\n  // We don\'t need to do this in C++11 because we do the check once on\n  // the qualifier.\n  //\n  // FIXME: diagnose the following if we care enough:\n  //  struct A { int foo; };\n  //  struct B : A { using A::foo; };\n  //  template <class T> struct C : A {};\n  //  template <class T> struct D : C<T> { using B::foo; } // <---\n  // This is invalid (during instantiation) in C++03 because B::foo\n  // resolves to the using decl in B, which is not a base class of D<T>.\n  // We can\'t diagnose it immediately because C<T> is an unknown\n  // specialization. The UsingShadowDecl in D<T> then points directly\n  // to A::foo, which will look well-formed when we instantiate.\n  // The right solution is to not collapse the shadow-decl chain.\n  if (!getLangOpts().CPlusPlus11 && CurContext->isRecord())\n    if (auto *Using = dyn_cast<UsingDecl>(BUD)) {\n      if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(OrigRec)) {\n        Diag(Using->getQualifierLoc().getBeginLoc(), diag::err_using_decl_nested_name_specifier_is_not_base_class) << Using->getQualifier() << cast<CXXRecordDecl>(CurContext) << Using->getQualifierLoc().getSourceRange();"},{z,11329,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  if (getLangOpts().CPlusPlus11) {\n    if (cast<CXXRecordDecl>(CurContext)->isProvablyNotDerivedFrom(cast<CXXRecordDecl>(NamedContext))) {\n      if (!cast<CXXRecordDecl>(NamedContext)->isInvalidDecl()) {\n        Diag(SS.getBeginLoc(), diag::err_using_decl_nested_name_specifier_is_not_base_class) << SS.getScopeRep() << cast<CXXRecordDecl>(CurContext) << SS.getRange();"},{z,11369,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  Diag(SS.getRange().getBegin(), diag::err_using_decl_nested_name_specifier_is_not_base_class) << SS.getScopeRep() << cast<CXXRecordDecl>(CurContext) << SS.getRange();"}}

[j]={{z,11299,"/// Checks that the given nested-name qualifier used in a using decl\n/// in the current context is appropriately related to the current\n/// scope.  If an error is found, diagnoses it and returns true.\n/// R is nullptr, if the caller has not (yet) done a lookup, otherwise it\'s the\n/// result of that lookup. UD is likewise nullptr, except when we have an\n/// already-populated UsingDecl whose shadow decls contain the same information\n/// (i.e. we\'re instantiating a UsingDecl with non-dependent scope).\nbool Sema::CheckUsingDeclQualifier(SourceLocation UsingLoc, bool HasTypename, const CXXScopeSpec &SS, const DeclarationNameInfo &NameInfo, SourceLocation NameLoc, const LookupResult *R, const UsingDecl *UD) {\n  // The current scope is a record.\n  if (!NamedContext->isRecord()) {\n    Diag(SS.getBeginLoc(), Cxx20Enumerator ? diag::warn_cxx17_compat_using_decl_non_member_enumerator : diag::err_using_decl_nested_name_specifier_is_not_class) << SS.getScopeRep() << SS.getRange();"}}

[j]={{z,11176,"/// 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  for (LookupResult::iterator I = Prev.begin(), E = Prev.end(); I != E; ++I) {\n    Diag(NameLoc, diag::err_using_decl_redeclaration) << SS.getRange();"}}

[j]={{Gc,2857,"template <typename T> Decl *TemplateDeclInstantiator::instantiateUnresolvedUsingDecl(T *D, bool InstantiatingPackElement) {\n  // If this is a pack expansion, expand it now.\n  if (D->isPackExpansion() && !InstantiatingPackElement) {\n    // Within a function, we don\'t have any normal way to check for conflicts\n    // between shadow declarations from different using declarations in the\n    // same pack expansion, but this is always ill-formed because all expansions\n    // must produce (conflicting) enumerators.\n    //\n    // Sadly we can\'t just reject this in the template definition because it\n    // could be valid if the pack is empty or has exactly one expansion.\n    if (D->getDeclContext()->isFunctionOrMethod() && *NumExpansions > 1) {\n      SemaRef.Diag(D->getEllipsisLoc(), diag::err_using_decl_redeclaration_expansion);"}}

[j]={{z,10365,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  case UnqualifiedIdKind::IK_TemplateId:\n    Diag(Name.getBeginLoc(), diag::err_using_decl_template_id) << SourceRange(Name.TemplateId->LAngleLoc, Name.TemplateId->RAngleLoc);"}}

[j]={{z,11003,"/// Builds a using declaration.\n///\n/// \\param IsInstantiation - Whether this call arises from an\n///  instantiation of an unresolved using declaration.  We treat\n///  the lookup differently for these declarations.\nNamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists) {\n  if (HasTypenameKeyword) {\n  } else {\n    // If we asked for a non-typename and we got a type, error out,\n    // but only if this is an instantiation of an unresolved using\n    // decl.  Otherwise just silently find the type name.\n    if (IsInstantiation && R.getAsSingle<TypeDecl>()) {\n      Diag(IdentLoc, diag::err_using_dependent_value_is_type);"}}

[j]={{z,10235,"static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident) {\n  if (TypoCorrection Corrected = S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS, CCC, Sema::CTK_ErrorRecovery)) {\n    if (DeclContext *DC = S.computeDeclContext(SS, false)) {\n      S.diagnoseTypo(Corrected, S.PDiag(diag::err_using_directive_member_suggest) << Ident << DC << DroppedSpecifier << SS.getRange(), S.PDiag(diag::note_namespace_defined_here));"},{"clang/unittests/Sema/ExternalSemaSourceTest.cpp",57,"/// Counts the number of typo-correcting diagnostics correcting from one name to\n/// another while still passing all diagnostics along a chain of consumers.\nclass DiagnosticWatcher : public clang::DiagnosticConsumer {\n  void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) override {\n    if (Info.getID() - 1 == diag::err_using_directive_member_suggest) {"}}

[j]={{z,10237,"static bool TryNamespaceTypoCorrection(Sema &S, LookupResult &R, Scope *Sc, CXXScopeSpec &SS, SourceLocation IdentLoc, IdentifierInfo *Ident) {\n  if (TypoCorrection Corrected = S.CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), Sc, &SS, CCC, Sema::CTK_ErrorRecovery)) {\n    if (DeclContext *DC = S.computeDeclContext(SS, false)) {\n    } else {\n      S.diagnoseTypo(Corrected, S.PDiag(diag::err_using_directive_suggest) << Ident, S.PDiag(diag::note_namespace_defined_here));"}}

[j]={{z,11049,"NamedDecl *Sema::BuildUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation NameLoc, TypeSourceInfo *EnumType, EnumDecl *ED) {\n  if (CurContext->getRedeclContext()->isRecord()) {\n    for (NamedDecl *D : Previous)\n      if (UsingEnumDecl *UED = dyn_cast<UsingEnumDecl>(D))\n        if (UED->getEnumDecl() == ED) {\n          Diag(UsingLoc, diag::err_using_enum_decl_redeclaration) << SourceRange(EnumLoc, NameLoc);"}}

[j]={{L,647,"/// ParseUsingDeclaration - Parse C++ using-declaration or alias-declaration.\n/// Assumes that \'using\' was already seen.\n///\n///    using-declaration: [C++ 7.3.p3: namespace.udecl]\n///      \'using\' using-declarator-list[opt] ;\n///\n///    using-declarator-list: [C++1z]\n///      using-declarator \'...\'[opt]\n///      using-declarator-list \',\' using-declarator \'...\'[opt]\n///\n///    using-declarator-list: [C++98-14]\n///      using-declarator\n///\n///    alias-declaration: C++11 [dcl.dcl]p1\n///      \'using\' identifier attribute-specifier-seq[opt] = type-id ;\n///\n///    using-enum-declaration: [C++20, dcl.enum]\n///      \'using\' elaborated-enum-specifier ;\n///      The terminal name of the elaborated-enum-specifier undergoes\n///      ordinary lookup\n///\n///    elaborated-enum-specifier:\n///      \'enum\' nested-name-specifier[opt] identifier\nParser::DeclGroupPtrTy Parser::ParseUsingDeclaration(DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, SourceLocation UsingLoc, SourceLocation &DeclEnd, ParsedAttributes &PrefixAttrs, AccessSpecifier AS) {\n  if (TryConsumeToken(tok::kw_enum, UELoc) && !InInitStatement) {\n    if (!Tok.is(tok::identifier)) {\n      Diag(Tok.getLocation(), diag::err_using_enum_expect_identifier) << Tok.is(tok::kw_enum);"}}

[j]={{z,10409,"Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation IdentLoc, IdentifierInfo &II, CXXScopeSpec *SS) {\n  if (EnumTy.isNull()) {\n    Diag(IdentLoc, SS && isDependentScopeSpecifier(*SS) ? diag::err_using_enum_is_dependent : diag::err_unknown_typename) << II.getName() << SourceRange(SS ? SS->getBeginLoc() : IdentLoc, IdentLoc);"}}

[j]={{z,10415,"Decl *Sema::ActOnUsingEnumDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation EnumLoc, SourceLocation IdentLoc, IdentifierInfo &II, CXXScopeSpec *SS) {\n  if (!Enum) {\n    Diag(IdentLoc, diag::err_using_enum_not_enum) << EnumTy;"}}

[j]={{z,10868,"/// Builds a using declaration.\n///\n/// \\param IsInstantiation - Whether this call arises from an\n///  instantiation of an unresolved using declaration.  We treat\n///  the lookup differently for these declarations.\nNamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists) {\n  // \'using_if_exists\' doesn\'t make sense on an inherited constructor.\n  if (IsUsingIfExists && UsingName.getName().getNameKind() == DeclarationName::CXXConstructorName) {\n    Diag(UsingLoc, diag::err_using_if_exists_on_ctor);"}}

[j]={{L,2400,"/// ParseCXXClassMemberDeclaration - Parse a C++ class member declaration.\n///\n///      member-declaration:\n///        decl-specifier-seq[opt] member-declarator-list[opt] \';\'\n///        function-definition \';\'[opt]\n///        ::[opt] nested-name-specifier template[opt] unqualified-id \';\'[TODO]\n///        using-declaration                                            [TODO]\n/// [C++0x] static_assert-declaration\n///        template-declaration\n/// [GNU]  \'__extension__\' member-declaration\n///\n///      member-declarator-list:\n///        member-declarator\n///        member-declarator-list \',\' member-declarator\n///\n///      member-declarator:\n///        declarator virt-specifier-seq[opt] pure-specifier[opt]\n/// [C++2a] declarator requires-clause\n///        declarator constant-initializer[opt]\n/// [C++11] declarator brace-or-equal-initializer[opt]\n///        identifier[opt] \':\' constant-expression\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\n///\n///      virt-specifier:\n///        override\n///        final\n/// [MS]    sealed\n///\n///      pure-specifier:\n///        \'= 0\'\n///\n///      constant-initializer:\n///        \'=\' constant-expression\n///\nParser::DeclGroupPtrTy Parser::ParseCXXClassMemberDeclaration(AccessSpecifier AS, ParsedAttributes &AccessAttrs, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject *TemplateDiags) {\n  if (Tok.is(tok::kw_using)) {\n    if (Tok.is(tok::kw_namespace)) {\n      Diag(UsingLoc, diag::err_using_namespace_in_class);"}}

[j]={{z,10338,"Decl *Sema::ActOnUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, SourceLocation TypenameLoc, CXXScopeSpec &SS, UnqualifiedId &Name, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList) {\n  if (SS.isEmpty()) {\n    Diag(Name.getBeginLoc(), diag::err_using_requires_qualname);"}}

[j]={{z,10993,"/// Builds a using declaration.\n///\n/// \\param IsInstantiation - Whether this call arises from an\n///  instantiation of an unresolved using declaration.  We treat\n///  the lookup differently for these declarations.\nNamedDecl *Sema::BuildUsingDeclaration(Scope *S, AccessSpecifier AS, SourceLocation UsingLoc, bool HasTypenameKeyword, SourceLocation TypenameLoc, CXXScopeSpec &SS, DeclarationNameInfo NameInfo, SourceLocation EllipsisLoc, const ParsedAttributesView &AttrList, bool IsInstantiation, bool IsUsingIfExists) {\n  if (HasTypenameKeyword) {\n    // If we asked for a typename and got a non-type decl, error out.\n    if (!R.getAsSingle<TypeDecl>() && !R.getAsSingle<UnresolvedUsingIfExistsDecl>()) {\n      Diag(IdentLoc, diag::err_using_typename_non_type);"}}

[j]={{V,685,"/// Build a Microsoft __uuidof expression with a type operand.\nExprResult Sema::BuildCXXUuidof(QualType Type, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc) {\n  if (!Operand->getType()->isDependentType()) {\n    if (UuidAttrs.size() > 1)\n      return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));"},{V,705,"/// Build a Microsoft __uuidof expression with an expression operand.\nExprResult Sema::BuildCXXUuidof(QualType Type, SourceLocation TypeidLoc, Expr *E, SourceLocation RParenLoc) {\n  if (!E->getType()->isDependentType()) {\n    if (E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {\n    } else {\n      if (UuidAttrs.size() > 1)\n        return ExprError(Diag(TypeidLoc, diag::err_uuidof_with_multiple_guids));"}}

[j]={{V,683,"/// Build a Microsoft __uuidof expression with a type operand.\nExprResult Sema::BuildCXXUuidof(QualType Type, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc) {\n  if (!Operand->getType()->isDependentType()) {\n    if (UuidAttrs.empty())\n      return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));"},{V,703,"/// Build a Microsoft __uuidof expression with an expression operand.\nExprResult Sema::BuildCXXUuidof(QualType Type, SourceLocation TypeidLoc, Expr *E, SourceLocation RParenLoc) {\n  if (!E->getType()->isDependentType()) {\n    if (E->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) {\n    } else {\n      if (UuidAttrs.empty())\n        return ExprError(Diag(TypeidLoc, diag::err_uuidof_without_guid));"}}

[j]={{y,14899,"ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc) {\n  // CUDA device code does not support varargs.\n  if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice) {\n    if (const FunctionDecl *F = dyn_cast<FunctionDecl>(CurContext)) {\n      if (T == CFT_Global || T == CFT_Device || T == CFT_HostDevice)\n        return ExprError(Diag(E->getBeginLoc(), diag::err_va_arg_in_device));"},{y,14905,"ExprResult Sema::BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E, TypeSourceInfo *TInfo, SourceLocation RPLoc) {\n  // NVPTX does not support va_arg expression.\n  if (getLangOpts().OpenMP && getLangOpts().OpenMPIsTargetDevice && Context.getTargetInfo().getTriple().isNVPTX())\n    targetDiag(E->getBeginLoc(), diag::err_va_arg_in_device);"}}

[j]={{bb,7597,"static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam = nullptr) {\n  if (auto *Block = dyn_cast<BlockDecl>(Caller)) {\n  } else if (auto *FD = dyn_cast<FunctionDecl>(Caller)) {\n  } else if (auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {\n  } else if (isa<CapturedDecl>(Caller)) {\n    S.Diag(Fn->getBeginLoc(), diag::err_va_start_captured_stmt);"}}

[j]={{bb,7606,"static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam = nullptr) {\n  if (!IsVariadic) {\n    S.Diag(Fn->getBeginLoc(), diag::err_va_start_fixed_function);"}}

[j]={{bb,7601,"static bool checkVAStartIsInVariadicFunction(Sema &S, Expr *Fn, ParmVarDecl **LastParam = nullptr) {\n  if (auto *Block = dyn_cast<BlockDecl>(Caller)) {\n  } else if (auto *FD = dyn_cast<FunctionDecl>(Caller)) {\n  } else if (auto *MD = dyn_cast<ObjCMethodDecl>(Caller)) {\n  } else if (isa<CapturedDecl>(Caller)) {\n  } else {\n    S.Diag(Fn->getBeginLoc(), diag::err_va_start_outside_function);"}}

[j]={{bb,7569,"/// Check that the user is calling the appropriate va_start builtin for the\n/// target and calling convention.\nstatic bool checkVAStartABI(Sema &S, unsigned BuiltinID, Expr *Fn) {\n  if (IsX64 || IsAArch64) {\n    if (IsMSVAStart) {\n    } else {\n      // On x86-64/AArch64 Unix, don\'t allow this in Win64 ABI functions.\n      // On x64 Windows, don\'t allow this in System V ABI functions.\n      // (Yes, that means there\'s no corresponding way to support variadic\n      // System V ABI functions on Windows.)\n      if ((IsWindows && CC == CC_X86_64SysV) || (!IsWindows && CC == CC_Win64))\n        return S.Diag(Fn->getBeginLoc(), diag::err_va_start_used_in_wrong_abi_function) << !IsWindows;"}}

[j]={{V,1377,"ExprResult Sema::BuildCXXTypeConstructExpr(TypeSourceInfo *TInfo, SourceLocation LParenOrBraceLoc, MultiExprArg Exprs, SourceLocation RParenOrBraceLoc, bool ListInitialization) {\n  if (Ty->isArrayType()) {\n    if (!ListInitialization)\n      return ExprError(Diag(TyBeginLoc, diag::err_value_init_for_array_type) << FullRange);"}}

[j]={{W,2683,"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        } else if (VAOCtx.isInVAOpt()) {\n          if (Tok.is(tok::r_paren)) {\n            if (VAOCtx.sawClosingParen()) {\n              if (Tokens[Tokens.size() - 2].is(tok::hashhash)) {\n                Diag(Tok, diag::err_vaopt_paste_at_end);"}}

[j]={{W,2673,"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.is(tok::hashhash)) {\n            Diag(Tok, diag::err_vaopt_paste_at_start);"}}

[j]={{Gc,3596,"/// Instantiate the declaration of a variable template partial\n/// specialization.\n///\n/// \\param VarTemplate the (instantiated) variable template that is partially\n/// specialized by the instantiation of \\p PartialSpec.\n///\n/// \\param PartialSpec the (uninstantiated) variable template partial\n/// specialization that we are instantiating.\n///\n/// \\returns The instantiated partial specialization, if successful; otherwise,\n/// NULL to indicate an error.\nVarTemplatePartialSpecializationDecl *TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec) {\n  if (PrevDecl) {\n    SemaRef.Diag(PartialSpec->getLocation(), diag::err_var_partial_spec_redeclared) << WrittenTy->getType();"}}

[j]={{E,3794,"DeclResult Sema::ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization) {\n  if (!VarTemplate) {\n    return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template) << IsPartialSpecialization;"}}

[j]={{E,3793,"DeclResult Sema::ActOnVarTemplateSpecialization(Scope *S, Declarator &D, TypeSourceInfo *DI, SourceLocation TemplateKWLoc, TemplateParameterList *TemplateParams, StorageClass SC, bool IsPartialSpecialization) {\n  if (!VarTemplate) {\n    if (FnTemplate)\n      return Diag(D.getIdentifierLoc(), diag::err_var_spec_no_template_but_method) << FnTemplate->getDeclName();"}}

[j]={{Gc,943,"Decl *TemplateDeclInstantiator::VisitVarDecl(VarDecl *D, bool InstantiatingVarTemplate, ArrayRef<BindingDecl *> *Bindings) {\n  if (DI->getType()->isFunctionType()) {\n    SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function) << D->isStaticDataMember() << DI->getType();"},{Gc,3276,"Decl *TemplateDeclInstantiator::VisitVarTemplateSpecializationDecl(VarTemplateDecl *VarTemplate, VarDecl *D, const TemplateArgumentListInfo &TemplateArgsInfo, ArrayRef<TemplateArgument> Converted, VarTemplateSpecializationDecl *PrevDecl) {\n  if (DI->getType()->isFunctionType()) {\n    SemaRef.Diag(D->getLocation(), diag::err_variable_instantiates_to_function) << D->isStaticDataMember() << DI->getType();"},{Gc,3607,"/// Instantiate the declaration of a variable template partial\n/// specialization.\n///\n/// \\param VarTemplate the (instantiated) variable template that is partially\n/// specialized by the instantiation of \\p PartialSpec.\n///\n/// \\param PartialSpec the (uninstantiated) variable template partial\n/// specialization that we are instantiating.\n///\n/// \\returns The instantiated partial specialization, if successful; otherwise,\n/// NULL to indicate an error.\nVarTemplatePartialSpecializationDecl *TemplateDeclInstantiator::InstantiateVarTemplatePartialSpecialization(VarTemplateDecl *VarTemplate, VarTemplatePartialSpecializationDecl *PartialSpec) {\n  if (DI->getType()->isFunctionType()) {\n    SemaRef.Diag(PartialSpec->getLocation(), diag::err_variable_instantiates_to_function) << PartialSpec->isStaticDataMember() << DI->getType();"}}

[j]={{y,6614,"ExprResult Sema::BuildCompoundLiteralExpr(SourceLocation LParenLoc, TypeSourceInfo *TInfo, SourceLocation RParenLoc, Expr *LiteralExpr) {\n  if (literalType->isArrayType()) {\n    if (literalType->isVariableArrayType()) {\n      if ((LangOpts.CPlusPlus || NumInits.value_or(0)) && !tryToFixVariablyModifiedVarType(TInfo, literalType, LParenLoc, diag::err_variable_object_no_init))"},{T,1613,"void InitListChecker::CheckArrayType(const InitializedEntity &Entity, InitListExpr *IList, QualType &DeclType, llvm::APSInt elementIndex, bool SubobjectIsDesignatorContext, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(arrayType)) {\n    if (!VerifyOnly) {\n      // C2x 6.7.9p4: An entity of variable length array type shall not be\n      // initialized except by an empty initializer.\n      //\n      // The C extension warnings are issued from ParseBraceInitializer() and\n      // do not need to be issued here. However, we continue to issue an error\n      // in the case there are initializers or we are compiling C++. We allow\n      // use of VLAs in C++, but it\'s not clear we want to allow {} to zero\n      // init a VLA in C++ in all cases (such as with non-trivial constructors).\n      // FIXME: should we allow this construct in C++ when it makes sense to do\n      // so?\n      if (HasErr)\n        SemaRef.Diag(VAT->getSizeExpr()->getBeginLoc(), diag::err_variable_object_no_init) << VAT->getSizeExpr()->getSourceRange();"},{T,4639,"static void TryOrBuildParenListInitialization(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args, InitializationSequence &Sequence, bool VerifyOnly, ExprResult *Result = nullptr) {\n  if (const ArrayType *AT = S.getASTContext().getAsArrayType(Entity.getType())) {\n    // C++ [dcl.init]p16.5\n    //  if the destination type is an array, the object is initialized as\n    //  follows. Let x1, . . . , xk be the elements of the expression-list. If\n    //  the destination type is an array of unknown bound, it is defined as\n    //  having k elements.\n    if (const ConstantArrayType *CAT = S.getASTContext().getAsConstantArrayType(Entity.getType())) {\n    } else if (const VariableArrayType *VAT = S.getASTContext().getAsVariableArrayType(Entity.getType())) {\n      S.Diag(SE->getBeginLoc(), diag::err_variable_object_no_init) << SE->getSourceRange();"},{T,8153,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_VariableLengthArrayHasInitializer:\n    S.Diag(Kind.getLocation(), diag::err_variable_object_no_init) << Args[0]->getSourceRange();"}}

[j]={{V,2084,"/// Checks that a type is suitable as the allocated type\n/// in a new-expression.\nbool Sema::CheckAllocatedType(QualType AllocType, SourceLocation Loc, SourceRange R) {\n  // C++ 5.3.4p1: \"[The] type shall be a complete object type, but not an\n  //  abstract class type or array thereof.\n  if (AllocType->isFunctionType())\n  else if (AllocType->isReferenceType())\n  else if (!AllocType->isDependentType() && RequireCompleteSizedType(Loc, AllocType, diag::err_new_incomplete_or_sizeless_type, R))\n  else if (RequireNonAbstractType(Loc, AllocType, diag::err_allocation_of_abstract_type))\n  else if (AllocType->isVariablyModifiedType())\n    return Diag(Loc, diag::err_variably_modified_new_type) << AllocType;"}}

[j]={{E,1195,"QualType Sema::CheckNonTypeTemplateParameterType(QualType T, SourceLocation Loc) {\n  // We don\'t allow variably-modified types as the type of non-type template\n  // parameters.\n  if (T->isVariablyModifiedType()) {\n    Diag(Loc, diag::err_variably_modified_nontype_template_param) << T;"}}

[j]={{E,5315,"/// Check a template argument against its corresponding\n/// template type parameter.\n///\n/// This routine implements the semantics of C++ [temp.arg.type]. It\n/// returns true if an error occurred, and false otherwise.\nbool Sema::CheckTemplateArgument(TypeSourceInfo *ArgInfo) {\n  if (CanonArg->isVariablyModifiedType()) {\n    return Diag(SR.getBegin(), diag::err_variably_modified_template_arg) << Arg;"}}

[j]={{V,509,"/// Build a C++ typeid expression with a type operand.\nExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, TypeSourceInfo *Operand, SourceLocation RParenLoc) {\n  if (T->isVariablyModifiedType())\n    return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << T);"},{V,576,"/// Build a C++ typeid expression with an expression operand.\nExprResult Sema::BuildCXXTypeId(QualType TypeInfoType, SourceLocation TypeidLoc, Expr *E, SourceLocation RParenLoc) {\n  if (E->getType()->isVariablyModifiedType())\n    return ExprError(Diag(TypeidLoc, diag::err_variably_modified_typeid) << E->getType());"}}

[j]={{w,9318,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (getLangOpts().CUDA) {\n    // Variadic functions, other than a *declaration* of printf, are not allowed\n    // in device-side CUDA code, unless someone passed\n    // -fcuda-allow-variadic-functions.\n    if (!getLangOpts().CUDAAllowVariadicFunctions && NewFD->isVariadic() && (NewFD->hasAttr<CUDADeviceAttr>() || NewFD->hasAttr<CUDAGlobalAttr>()) && !(II && II->isStr(\"printf\") && NewFD->isExternC() && !D.isFunctionDefinition())) {\n      Diag(NewFD->getLocation(), diag::err_variadic_device_fn);"}}

[j]={{bb,7903,"// Customized Sema Checking for VSX builtins that have the following signature:\n// vector [...] builtinName(vector [...], vector [...], const int);\n// Which takes the same type of vectors (any legal vector type) for the first\n// two arguments and takes compile time constant for the third argument.\n// Example builtins are :\n// vector double vec_xxpermdi(vector double, vector double, int);\n// vector short vec_xxsldwi(vector short, vector short, int);\nbool Sema::SemaBuiltinVSX(CallExpr *TheCall) {\n  // Check the first two arguments are the same type.\n  if (!Context.hasSameUnqualifiedType(Arg1Ty, Arg2Ty)) {\n    return Diag(BuiltinLoc, diag::err_vec_builtin_incompatible_vector) << TheCall->getDirectCallee() << SourceRange(TheCall->getArg(0)->getBeginLoc(), TheCall->getArg(1)->getEndLoc());"},{bb,7941,"/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector.\n// This is declared to take (...), so we have to check everything.\nExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {\n  if (!TheCall->getArg(0)->isTypeDependent() && !TheCall->getArg(1)->isTypeDependent()) {\n    // Check to see if we have a call with 2 vector arguments, the unary shuffle\n    // with mask.  If so, verify that RHS is an integer vector type with the\n    // same number of elts as lhs.\n    if (TheCall->getNumArgs() == 2) {\n      if (!RHSType->hasIntegerRepresentation() || RHSType->castAs<VectorType>()->getNumElements() != numElements)\n        return ExprError(Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_incompatible_vector) << TheCall->getDirectCallee() << SourceRange(TheCall->getArg(1)->getBeginLoc(), TheCall->getArg(1)->getEndLoc()));"},{bb,7943,"/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector.\n// This is declared to take (...), so we have to check everything.\nExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {\n  if (!TheCall->getArg(0)->isTypeDependent() && !TheCall->getArg(1)->isTypeDependent()) {\n    // Check to see if we have a call with 2 vector arguments, the unary shuffle\n    // with mask.  If so, verify that RHS is an integer vector type with the\n    // same number of elts as lhs.\n    if (TheCall->getNumArgs() == 2) {\n    } else if (!Context.hasSameUnqualifiedType(LHSType, RHSType)) {\n      return ExprError(Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_incompatible_vector) << TheCall->getDirectCallee() << SourceRange(TheCall->getArg(0)->getBeginLoc(), TheCall->getArg(1)->getEndLoc()));"}}

[j]={{bb,7898,"// Customized Sema Checking for VSX builtins that have the following signature:\n// vector [...] builtinName(vector [...], vector [...], const int);\n// Which takes the same type of vectors (any legal vector type) for the first\n// two arguments and takes compile time constant for the third argument.\n// Example builtins are :\n// vector double vec_xxpermdi(vector double, vector double, int);\n// vector short vec_xxsldwi(vector short, vector short, int);\nbool Sema::SemaBuiltinVSX(CallExpr *TheCall) {\n  if ((!Arg1Ty->isVectorType() && !Arg1Ty->isDependentType()) || (!Arg2Ty->isVectorType() && !Arg2Ty->isDependentType())) {\n    return Diag(BuiltinLoc, diag::err_vec_builtin_non_vector) << TheCall->getDirectCallee() << SourceRange(TheCall->getArg(0)->getBeginLoc(), TheCall->getArg(1)->getEndLoc());"},{bb,7931,"/// SemaBuiltinShuffleVector - Handle __builtin_shufflevector.\n// This is declared to take (...), so we have to check everything.\nExprResult Sema::SemaBuiltinShuffleVector(CallExpr *TheCall) {\n  if (!TheCall->getArg(0)->isTypeDependent() && !TheCall->getArg(1)->isTypeDependent()) {\n    if (!LHSType->isVectorType() || !RHSType->isVectorType())\n      return ExprError(Diag(TheCall->getBeginLoc(), diag::err_vec_builtin_non_vector) << TheCall->getDirectCallee() << SourceRange(TheCall->getArg(0)->getBeginLoc(), TheCall->getArg(1)->getEndLoc()));"}}

[j]={{y,3734,"static bool CheckVecStepTraitOperandType(Sema &S, QualType T, SourceLocation Loc, SourceRange ArgRange) {\n  // [OpenCL 1.1 6.11.12] \"The vec_step built-in function takes a built-in\n  // scalar or vector data type argument...\"\n  // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic\n  // type (C99 6.2.5p18) or void.\n  if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {\n    S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type) << T << ArgRange;"}}

[j]={{T,1539,"void InitListChecker::CheckVectorType(const InitializedEntity &Entity, InitListExpr *IList, QualType DeclType, unsigned &Index, InitListExpr *StructuredList, unsigned &StructuredIndex) {\n  // OpenCL and HLSL require all elements to be initialized.\n  if (numEltsInit != maxElements) {\n    if (!VerifyOnly)\n      SemaRef.Diag(IList->getBeginLoc(), diag::err_vector_incorrect_num_initializers) << (numEltsInit < maxElements) << maxElements << numEltsInit;"}}

[j]={{nb,351,"// Tracker for markers in the input files. A marker is a comment of the form\n//\n//  n = 123; // #123\n//\n// ... that can be referred to by a later expected-* directive:\n//\n//  // expected-error@#123 {{undeclared identifier \'n\'}}\n//\n// Marker declarations must be at the start of a comment or preceded by\n// whitespace to distinguish them from uses of markers in directives.\nclass VerifyDiagnosticConsumer::MarkerTracker {\n  // Ensure we have no remaining deferred directives, and no\n  // multiply-defined-and-used markers.\n  void finalize() {\n    for (auto &MarkerInfo : Markers) {\n      if (M.RedefLoc.isValid() && M.UseLoc.isValid()) {\n        Diags.Report(M.UseLoc, diag::err_verify_ambiguous_marker) << Name;"}}

[j]={{nb,814,"/// Takes a list of diagnostics that have been generated but not matched\n/// by an expected-* directive and produces a diagnostic to the user from this.\nstatic unsigned PrintUnexpected(DiagnosticsEngine &Diags, SourceManager *SourceMgr, const_diag_iterator diag_begin, const_diag_iterator diag_end, const char *Kind) {\n  Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit() << Kind << /*Unexpected=*/true << OS.str();"},{nb,840,"/// Takes a list of diagnostics that were expected to have been generated\n/// but were not and produces a diagnostic to the user from this.\nstatic unsigned PrintExpected(DiagnosticsEngine &Diags, SourceManager &SourceMgr, std::vector<Directive *> &DL, const char *Kind) {\n  Diags.Report(diag::err_verify_inconsistent_diags).setForceEmit() << Kind << /*Unexpected=*/false << OS.str();"}}

[j]={{nb,275,"// Attach the specified directive to the line of code indicated by\n// \\p ExpectedLoc.\nvoid attachDirective(DiagnosticsEngine &Diags, const UnattachedDirective &UD, SourceLocation ExpectedLoc, bool MatchAnyFileAndLine = false, bool MatchAnyLine = false) {\n  if (!D->isValid(Error)) {\n    Diags.Report(UD.ContentBegin, diag::err_verify_invalid_content) << (UD.RegexKind ? \"regex\" : \"string\") << Error;"}}

[j]={{nb,441,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    if (NoDiag) {\n      if (Status == VerifyDiagnosticConsumer::HasOtherExpectedDirectives)\n        Diags.Report(Pos, diag::err_verify_invalid_no_diags) << /*IsExpectedNoDiagnostics=*/true;"},{nb,447,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    if (Status == VerifyDiagnosticConsumer::HasExpectedNoDiagnostics) {\n      Diags.Report(Pos, diag::err_verify_invalid_no_diags) << /*IsExpectedNoDiagnostics=*/false;"}}

[j]={{nb,544,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    // Next optional token: positive integer or a \'+\'.\n    if (PH.Next(D.Min)) {\n      // A positive integer can be followed by a \'+\' meaning min\n      // or more, or by a \'-\' meaning a range from min to max.\n      if (PH.Next(\"+\")) {\n      } else if (PH.Next(\"-\")) {\n        if (!PH.Next(D.Max) || D.Max < D.Min) {\n          Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin), diag::err_verify_invalid_range) << KindStr;"}}

[j]={{nb,569,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    // Search for token: }}\n    if (!PH.SearchClosingBrace(\"{{\", \"}}\")) {\n      Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin), diag::err_verify_missing_end) << KindStr;"}}

[j]={{nb,503,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    if (!PH.Next(\"@\")) {\n    } else {\n      if (FoundPlus || PH.Next(\"-\")) {\n      } else if (PH.Next(Line)) {\n      } else if (PH.NextMarker()) {\n      } else if (PP && PH.Search(\":\")) {\n        if (Filename == \"*\") {\n        } else {\n          if (!File) {\n            Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin), diag::err_verify_missing_file) << Filename << KindStr;"}}

[j]={{nb,494,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    if (!PH.Next(\"@\")) {\n    } else {\n      if (FoundPlus || PH.Next(\"-\")) {\n      } else if (PH.Next(Line)) {\n      } else if (PH.NextMarker()) {\n      } else if (PP && PH.Search(\":\")) {\n        if (Filename == \"*\") {\n          if (!PH.Next(\"*\")) {\n            Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin), diag::err_verify_missing_line) << \"\'*\'\";"},{nb,524,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    if (!PH.Next(\"@\")) {\n    } else {\n      if (ExpectedLoc.isInvalid() && !MatchAnyLine && Marker.empty()) {\n        Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin), diag::err_verify_missing_line) << KindStr;"}}

[j]={{nb,593,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    // Check that regex directives contain at least one regex.\n    if (D.RegexKind && D.Text.find(\"{{\") == StringRef::npos) {\n      Diags.Report(D.ContentBegin, diag::err_verify_missing_regex) << D.Text;"}}

[j]={{nb,562,"/// ParseDirective - Go through the comment and see if it indicates expected\n/// diagnostics. If so, then put them in the appropriate directive list.\n///\n/// Returns true if any valid directives were found.\nstatic bool ParseDirective(StringRef S, ExpectedData *ED, SourceManager &SM, Preprocessor *PP, SourceLocation Pos, VerifyDiagnosticConsumer::DirectiveStatus &Status, VerifyDiagnosticConsumer::MarkerTracker &Markers) {\n  for (ParseHelper PH(S); !PH.Done();) {\n    // Next token: {{\n    if (!PH.Next(\"{{\")) {\n      Diags.Report(Pos.getLocWithOffset(PH.C - PH.Begin), diag::err_verify_missing_start) << KindStr;"}}

[j]={{nb,1007,"#endif // !NDEBUG\n  if (SrcManager) {\n    // Produce an error if no expected-* directives could be found in the\n    // source file(s) processed.\n    if (Status == HasNoDirectives) {\n      Diags.Report(diag::err_verify_no_directives).setForceEmit();"}}

[j]={{nb,358,"// Tracker for markers in the input files. A marker is a comment of the form\n//\n//  n = 123; // #123\n//\n// ... that can be referred to by a later expected-* directive:\n//\n//  // expected-error@#123 {{undeclared identifier \'n\'}}\n//\n// Marker declarations must be at the start of a comment or preceded by\n// whitespace to distinguish them from uses of markers in directives.\nclass VerifyDiagnosticConsumer::MarkerTracker {\n  // Ensure we have no remaining deferred directives, and no\n  // multiply-defined-and-used markers.\n  void finalize() {\n    for (auto &DeferredPair : DeferredDirectives) {\n      Diags.Report(DeferredPair.second.front().DirectivePos, diag::err_verify_no_such_marker) << DeferredPair.first();"}}

[j]={{"clang/lib/CodeGen/Targets/AVR.cpp",121,"class AVRTargetCodeGenInfo : public TargetCodeGenInfo {\n  LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const override {\n    // Check if global/static variable is defined in address space\n    // 1~6 (__flash, __flash1, __flash2, __flash3, __flash4, __flash5)\n    // but not constant.\n    if (D) {\n      if (isTargetAddressSpace(AS) && 1 <= toTargetAddressSpace(AS) && toTargetAddressSpace(AS) <= 6 && !D->getType().isConstQualified())\n        CGM.getDiags().Report(D->getLocation(), diag::err_verify_nonconst_addrspace) << \"__flash*\";"}}

[j]={{"clang/lib/AST/VTableBuilder.cpp",3083,"// We want to select the path which introduces the most covariant overrides.  If\n// two paths introduce overrides which the other path doesn\'t contain, issue a\n// diagnostic.\nstatic const FullPathTy *selectBestPath(ASTContext &Context, const CXXRecordDecl *RD, const VPtrInfo &Info, std::list<FullPathTy> &FullPaths) {\n  for (const FullPathTy &SpecificPath : FullPaths) {\n    if (MissingOverrides.empty()) {\n    } else {\n      Diags.Report(RD->getLocation(), diag::err_vftable_ambiguous_component) << RD;"}}

[j]={{F,1966,"/// ParseDeclGroup - Having concluded that this is either a function\n/// definition or a group of object declarations, actually parse the\n/// result.\nParser::DeclGroupPtrTy Parser::ParseDeclGroup(ParsingDeclSpec &DS, DeclaratorContext Context, ParsedAttributes &Attrs, SourceLocation *DeclEnd, ForRangeInit *FRI) {\n  if (D.isFunctionDeclarator()) {\n    // We\'re at the point where the parsing of function declarator is finished.\n    //\n    // A common error is that users accidently add a virtual specifier\n    // (e.g. override) in an out-line method definition.\n    // We attempt to recover by stripping all these specifiers coming after\n    // the declarator.\n    while (auto Specifier = isCXX11VirtSpecifier()) {\n      Diag(Tok, diag::err_virt_specifier_outside_class) << VirtSpecifiers::getSpecifierName(Specifier) << FixItHint::CreateRemoval(Tok.getLocation());"}}

[j]={{w,8572,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (getLangOpts().CPlusPlus) {\n    // If this is a method defined in an __interface, and is not a constructor\n    // or an overloaded operator, then set the pure flag (isVirtual will already\n    // return true).\n    if (const CXXRecordDecl *Parent = dyn_cast<CXXRecordDecl>(NewFD->getDeclContext())) {\n      // C++ [class.union]p2\n      //  A union can have member functions, but not virtual functions.\n      if (isVirtual && Parent->isUnion()) {\n        Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_in_union);"}}

[j]={{w,8681,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [dcl.fct.spec]p5:\n    //  The virtual specifier shall only be used in declarations of\n    //  nonstatic class member functions that appear within a\n    //  member-specification of a class declaration; see 10.3.\n    //\n    if (isVirtual && !NewFD->isInvalidDecl()) {\n      if (!isVirtualOkay) {\n      } else if (!CurContext->isRecord()) {\n      } else if (NewFD->getDescribedFunctionTemplate()) {\n        Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_member_function_template) << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());"}}

[j]={{w,5900,"/// Diagnose function specifiers on a declaration of an identifier that\n/// does not identify a function.\nvoid Sema::DiagnoseFunctionSpecifiers(const DeclSpec &DS) {\n  // FIXME: We should probably indicate the identifier in question to avoid\n  // confusion for constructs like \"virtual int a(), b;\"\n  if (DS.isVirtualSpecified())\n    Diag(DS.getVirtualSpecLoc(), diag::err_virtual_non_function);"},{w,8674,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [dcl.fct.spec]p5:\n    //  The virtual specifier shall only be used in declarations of\n    //  nonstatic class member functions that appear within a\n    //  member-specification of a class declaration; see 10.3.\n    //\n    if (isVirtual && !NewFD->isInvalidDecl()) {\n      if (!isVirtualOkay) {\n        Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_non_function);"}}

[j]={{w,8677,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (getLangOpts().CPlusPlus) {\n    // C++ [dcl.fct.spec]p5:\n    //  The virtual specifier shall only be used in declarations of\n    //  nonstatic class member functions that appear within a\n    //  member-specification of a class declaration; see 10.3.\n    //\n    if (isVirtual && !NewFD->isInvalidDecl()) {\n      if (!isVirtualOkay) {\n      } else if (!CurContext->isRecord()) {\n        Diag(D.getDeclSpec().getVirtualSpecLoc(), diag::err_virtual_out_of_class) << FixItHint::CreateRemoval(D.getDeclSpec().getVirtualSpecLoc());"}}

[j]={{w,7687,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  if ((isVM && NewVD->hasLinkage()) || (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {\n    if ((!FixedTInfo || FixedT.isNull()) && T->isVariableArrayType()) {\n      if (NewVD->isFileVarDecl())\n      else if (NewVD->isStaticLocal())\n      else\n        Diag(NewVD->getLocation(), diag::err_vla_decl_has_extern_linkage) << SizeRange;"}}

[j]={{w,7685,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  if ((isVM && NewVD->hasLinkage()) || (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {\n    if ((!FixedTInfo || FixedT.isNull()) && T->isVariableArrayType()) {\n      if (NewVD->isFileVarDecl())\n      else if (NewVD->isStaticLocal())\n        Diag(NewVD->getLocation(), diag::err_vla_decl_has_static_storage) << SizeRange;"}}

[j]={{w,5970,"void Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {\n  if (T->isVariablyModifiedType()) {\n    if (S->getFnParent() == nullptr) {\n      if (FixedTInfo) {\n      } else {\n        if (SizeIsNegative)\n        else if (T->isVariableArrayType())\n          Diag(NewTD->getLocation(), diag::err_vla_decl_in_file_scope);"},{w,7683,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  if ((isVM && NewVD->hasLinkage()) || (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {\n    if ((!FixedTInfo || FixedT.isNull()) && T->isVariableArrayType()) {\n      if (NewVD->isFileVarDecl())\n        Diag(NewVD->getLocation(), diag::err_vla_decl_in_file_scope) << SizeRange;"}}

[j]={{R,2284,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (getLangOpts().OpenCL) {\n  } else if (getLangOpts().C99) {\n  } else if (isSFINAEContext()) {\n    VLADiag = diag::err_vla_in_sfinae;"}}

[j]={{V,4240,"static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, QualType T) {\n  case UTT_IsBoundedArray:\n    Self.Diag(KeyLoc, diag::err_vla_unsupported) << 1 << tok::kw___is_bounded_array;"},{V,4247,"static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT, SourceLocation KeyLoc, QualType T) {\n  case UTT_IsUnboundedArray:\n    Self.Diag(KeyLoc, diag::err_vla_unsupported) << 1 << tok::kw___is_unbounded_array;"},{R,2356,"/// Build an array type.\n///\n/// \\param T The type of each element in the array.\n///\n/// \\param ASM C99 array size modifier (e.g., \'*\', \'static\').\n///\n/// \\param ArraySize Expression describing the size of the array.\n///\n/// \\param Brackets The range from the opening \'[\' to the closing \']\'.\n///\n/// \\param Entity The name of the entity that involves the array\n/// type, if known.\n///\n/// \\returns A suitable array type, if there are no errors. Otherwise,\n/// returns a NULL type.\nQualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM, Expr *ArraySize, unsigned Quals, SourceRange Brackets, DeclarationName Entity) {\n  if (T->isVariableArrayType() && !Context.getTargetInfo().isVLASupported()) {\n    targetDiag(Loc, IsCUDADevice ? diag::err_cuda_vla : diag::err_vla_unsupported) << (IsCUDADevice ? CurrentCUDATarget() : 0);"}}

[j]={{w,7696,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  if ((isVM && NewVD->hasLinkage()) || (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {\n    if (!FixedTInfo) {\n      if (NewVD->isFileVarDecl())\n      else\n        Diag(NewVD->getLocation(), diag::err_vm_decl_has_extern_linkage);"}}

[j]={{w,5974,"void Sema::CheckTypedefForVariablyModifiedType(Scope *S, TypedefNameDecl *NewTD) {\n  if (T->isVariablyModifiedType()) {\n    if (S->getFnParent() == nullptr) {\n      if (FixedTInfo) {\n      } else {\n        if (SizeIsNegative)\n        else if (T->isVariableArrayType())\n        else if (Oversized.getBoolValue())\n        else\n          Diag(NewTD->getLocation(), diag::err_vm_decl_in_file_scope);"},{w,7694,"void Sema::CheckVariableDeclarationType(VarDecl *NewVD) {\n  if ((isVM && NewVD->hasLinkage()) || (T->isVariableArrayType() && NewVD->hasGlobalStorage())) {\n    if (!FixedTInfo) {\n      if (NewVD->isFileVarDecl())\n        Diag(NewVD->getLocation(), diag::err_vm_decl_in_file_scope);"}}

[j]={{w,8937,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  // Functions returning a variably modified type violate C99 6.7.5.2p2\n  // because all functions have linkage.\n  if (!NewFD->isInvalidDecl() && NewFD->getReturnType()->isVariablyModifiedType()) {\n    Diag(NewFD->getLocation(), diag::err_vm_func_decl);"}}

[j]={{R,4842,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    case DeclaratorChunk::Function: {\n      // OpenCL disallows functions without a prototype, but it doesn\'t enforce\n      // strict prototypes as in C2x because it allows a function definition to\n      // have an identifier list. See OpenCL 3.0 6.11/g for more details.\n      if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.requiresStrictPrototypes() && !LangOpts.OpenCL) {\n      } else {\n        for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {\n          // Look for \'void\'.  void is allowed only as a single parameter to a\n          // function with no other parameters (C99 6.7.5.3p10).  We record\n          // int(void) as a FunctionProtoType with an empty parameter list.\n          if (ParamTy->isVoidType()) {\n            // If this is something like \'float(int, void)\', reject it.  \'void\'\n            // is an incomplete type (C99 6.2.5p19) and function decls cannot\n            // have parameters of incomplete type.\n            if (FTI.NumParams != 1 || FTI.isVariadic) {\n              S.Diag(FTI.Params[i].IdentLoc, diag::err_void_only_param);"}}

[j]={{R,4853,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  for (unsigned i = 0, e = D.getNumTypeObjects(); i != e; ++i) {\n    case DeclaratorChunk::Function: {\n      // OpenCL disallows functions without a prototype, but it doesn\'t enforce\n      // strict prototypes as in C2x because it allows a function definition to\n      // have an identifier list. See OpenCL 3.0 6.11/g for more details.\n      if (!FTI.NumParams && !FTI.isVariadic && !LangOpts.requiresStrictPrototypes() && !LangOpts.OpenCL) {\n      } else {\n        for (unsigned i = 0, e = FTI.NumParams; i != e; ++i) {\n          // Look for \'void\'.  void is allowed only as a single parameter to a\n          // function with no other parameters (C99 6.7.5.3p10).  We record\n          // int(void) as a FunctionProtoType with an empty parameter list.\n          if (ParamTy->isVoidType()) {\n            // If this is something like \'float(int, void)\', reject it.  \'void\'\n            // is an incomplete type (C99 6.2.5p19) and function decls cannot\n            // have parameters of incomplete type.\n            if (FTI.NumParams != 1 || FTI.isVariadic) {\n            } else if (FTI.Params[i].Ident) {\n            } else {\n              // Reject, but continue to parse \'float(const void)\'.\n              if (ParamTy.hasQualifiers())\n                S.Diag(DeclType.Loc, diag::err_void_param_qualified);"}}

[j]={{z,7452,"bool Sema::CheckExplicitlyDefaultedComparison(Scope *S, FunctionDecl *FD, DefaultedComparisonKind DCK) {\n  if (IsMethod) {\n    if (MD->isVolatile()) {\n      Diag(MD->getLocation(), diag::err_volatile_comparison_operator);"}}

[j]={{bb,7890,"// Customized Sema Checking for VSX builtins that have the following signature:\n// vector [...] builtinName(vector [...], vector [...], const int);\n// Which takes the same type of vectors (any legal vector type) for the first\n// two arguments and takes compile time constant for the third argument.\n// Example builtins are :\n// vector double vec_xxpermdi(vector double, vector double, int);\n// vector short vec_xxsldwi(vector short, vector short, int);\nbool Sema::SemaBuiltinVSX(CallExpr *TheCall) {\n  // Check the third argument is a compile time constant\n  if (!TheCall->getArg(2)->isIntegerConstantExpr(Context))\n    return Diag(TheCall->getBeginLoc(), diag::err_vsx_builtin_nonconstant_argument) << 3 /* argument index */ << TheCall->getDirectCallee() << SourceRange(TheCall->getArg(2)->getBeginLoc(), TheCall->getArg(2)->getEndLoc());"}}

[j]={{bb,16995,"/// Checks the argument at the given index is an integer.\nstatic bool CheckWasmBuiltinArgIsInteger(Sema &S, CallExpr *E, unsigned ArgIndex) {\n  if (!ArgExpr->getType()->isIntegerType()) {\n    return S.Diag(ArgExpr->getBeginLoc(), diag::err_wasm_builtin_arg_must_be_integer_type) << ArgIndex + 1 << ArgExpr->getSourceRange();"}}

[j]={{bb,16985,"/// Checks the argument at the given index is a WebAssembly table and if it\n/// is, sets ElTy to the element type.\nstatic bool CheckWasmBuiltinArgIsTable(Sema &S, CallExpr *E, unsigned ArgIndex, QualType &ElTy) {\n  if (!ATy || !ATy->getElementType().isWebAssemblyReferenceType()) {\n    return S.Diag(ArgExpr->getBeginLoc(), diag::err_wasm_builtin_arg_must_be_table_type) << ArgIndex + 1 << ArgExpr->getSourceRange();"}}

[j]={{bb,17067,"/// Check that the first argument is a WebAssembly table, the second is the\n/// value to use for new elements (of a type matching the table type), the\n/// third value is an integer.\nbool Sema::BuiltinWasmTableGrow(CallExpr *TheCall) {\n  if (!Context.hasSameType(ElTy, NewElemArg->getType())) {\n    return Diag(NewElemArg->getBeginLoc(), diag::err_wasm_builtin_arg_must_match_table_element_type) << 2 << 1 << NewElemArg->getSourceRange();"},{bb,17092,"/// Check that the first argument is a WebAssembly table, the second is an\n/// integer, the third is the value to use to fill the table (of a type\n/// matching the table type), and the fourth is an integer.\nbool Sema::BuiltinWasmTableFill(CallExpr *TheCall) {\n  if (!Context.hasSameType(ElTy, NewElemArg->getType())) {\n    return Diag(NewElemArg->getBeginLoc(), diag::err_wasm_builtin_arg_must_match_table_element_type) << 3 << 1 << NewElemArg->getSourceRange();"},{bb,17118,"/// Check that the first argument is a WebAssembly table, the second is also a\n/// WebAssembly table (of the same element type), and the third to fifth\n/// arguments are integers.\nbool Sema::BuiltinWasmTableCopy(CallExpr *TheCall) {\n  if (!Context.hasSameType(XElTy, YElTy)) {\n    return Diag(TableYArg->getBeginLoc(), diag::err_wasm_builtin_arg_must_match_table_element_type) << 2 << 1 << TableYArg->getSourceRange();"}}

[j]={{y,13001,"/// CheckAddressOfOperand - The operand of & must be either a function\n/// designator or an lvalue designating an object. If it is an lvalue, the\n/// object cannot be declared with storage class register or be a bit field.\n/// Note: The usual conversions are *not* applied to the operand of the &\n/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.\n/// In C++, the operand might be an overloaded function name, in which case\n/// we allow the \'&\' but retain the overloaded-function type.\nQualType Sema::CheckAddressOfOperand(ExprResult &OrigOp, SourceLocation OpLoc) {\n  // Cannot take the address of WebAssembly references or tables.\n  if (Context.getTargetInfo().getTriple().isWasm()) {\n    if (OpTy.isWebAssemblyReferenceType()) {\n      Diag(OpLoc, diag::err_wasm_ca_reference) << 1 << OrigOp.get()->getSourceRange();"},{y,16789,"/// Capture the given variable in the lambda.\nstatic bool captureInLambda(LambdaScopeInfo *LSI, ValueDecl *Var, SourceLocation Loc, const bool BuildAndDiagnose, QualType &CaptureType, QualType &DeclRefType, const bool RefersToCapturedVariable, const Sema::TryCaptureKind Kind, SourceLocation EllipsisLoc, const bool IsTopScope, Sema &S, bool Invalid) {\n  if (BuildAndDiagnose && S.Context.getTargetInfo().getTriple().isWasm() && CaptureType.getNonReferenceType().isWebAssemblyReferenceType()) {\n    S.Diag(Loc, diag::err_wasm_ca_reference) << 0;"}}

[j]={{Ab,2398,"void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle, bool ListInitialization) {\n  if (SrcType->isWebAssemblyTableType()) {\n    Self.Diag(OpRange.getBegin(), diag::err_wasm_cast_table) << 1 << SrcExpr.get()->getSourceRange();"},{Ab,2554,"/// Check the semantics of a C-style cast operation, in C.\nvoid CastOperation::CheckCStyleCast() {\n  if (SrcType->isWebAssemblyTableType()) {\n    Self.Diag(OpRange.getBegin(), diag::err_wasm_cast_table) << 1 << SrcExpr.get()->getSourceRange();"}}

[j]={{F,780,"void Parser::ParseWebAssemblyFuncrefTypeAttribute(ParsedAttributes &attrs) {\n  if (!getTargetInfo().getTriple().isWasm()) {\n    Diag(StartLoc, diag::err_wasm_funcref_not_wasm);"}}

[j]={{R,1946,"/// Build a pointer type.\n///\n/// \\param T The type to which we\'ll be building a pointer.\n///\n/// \\param Loc The location of the entity whose type involves this\n/// pointer type or, if there is no such entity, the location of the\n/// type that will have pointer type.\n///\n/// \\param Entity The name of the entity that involves the pointer\n/// type, if known.\n///\n/// \\returns A suitable pointer type, if there are no\n/// errors. Otherwise, returns a NULL type.\nQualType Sema::BuildPointerType(QualType T, SourceLocation Loc, DeclarationName Entity) {\n  // In WebAssembly, pointers to reference types and pointers to tables are\n  // illegal.\n  if (getASTContext().getTargetInfo().getTriple().isWasm()) {\n    if (T.isWebAssemblyReferenceType()) {\n      Diag(Loc, diag::err_wasm_reference_pr) << 0;"},{R,2029,"/// Build a reference type.\n///\n/// \\param T The type to which we\'ll be building a reference.\n///\n/// \\param Loc The location of the entity whose type involves this\n/// reference type or, if there is no such entity, the location of the\n/// type that will have reference type.\n///\n/// \\param Entity The name of the entity that involves the reference\n/// type, if known.\n///\n/// \\returns A suitable reference type, if there are no\n/// errors. Otherwise, returns a NULL type.\nQualType Sema::BuildReferenceType(QualType T, bool SpelledAsLValue, SourceLocation Loc, DeclarationName Entity) {\n  // In WebAssembly, references to reference types and tables are illegal.\n  if (getASTContext().getTargetInfo().getTriple().isWasm() && T.isWebAssemblyReferenceType()) {\n    Diag(Loc, diag::err_wasm_reference_pr) << 1;"}}