Module:ClangDiags/DiagsLongData5: Difference between revisions

local a="prefix";

local b="type";

local c="message";

local d="regex1";

local e="title";

local f="regex2";

local g="regex3";

local h="category";

local k="groups";

local l="maingroup";

local m="Semantic Issue";

local n="warning: ";

local o="Warning";

local p="(?:warning|error|fatal error)\\: ";

local q="";

local r="error: ";

local s="(?:error|fatal error)\\: ";

local u="pedantic";

local v="defaultactive";

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

local x="Parse Issue";

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

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

local A="Lexical or Preprocessor Issue";

local B="b1c4d5507fad";

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

local D="c++11-extensions";

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

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

local H="5a8987ca5113";

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

local J="c++20-extensions";

local K="gnu";

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

local M="95f50964fbf5";

local O="c++17-extensions";

local P="Downgradable Error";

local Q="(?:error|warning|fatal error)\\: ";

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

local S="c++0x-extensions";

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

local U="c99-extensions";

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

local Y=" \\[(?:\\-Werror,)?\\-Wc\\+\\+11\\-extensions[^\\]]*\\]";

local Z="clang/lib/Lex/Lexer.cpp";

local ab="c++2a-extensions";

local cb="clang/lib/Lex/LiteralSupport.cpp";

local db="microsoft-template";

local eb="c++23-extensions";

local fb=" \\[(?:\\-Werror,)?\\-Wc\\+\\+20\\-extensions[^\\]]*\\]";

local gb="c++1z-extensions";

local hb=" \\[(?:\\-Werror,)?\\-Wc\\+\\+17\\-extensions[^\\]]*\\]";

local ib="c++14-extensions";

local kb="PR20356: Fix all Sema warnings with mismatched ext_/warn_ versus";

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

local mb="1b98ccc4e957";

local nb="clang/lib/Frontend/VerifyDiagnosticConsumer.cpp";

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

local pb="most";

local qb="c2x-extensions";

local rb="all";

local sb="[C++20][Modules][3/8] Initial handling for module partitions.";

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

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

local yb="c99-designator";

local zb=" \\[(?:\\-Werror,)?\\-Wc\\+\\+23\\-extensions[^\\]]*\\]";

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

local Bb="clang/lib/Sema/SemaExceptionSpec.cpp";

local Cb="c++2b-extensions";

local Db=" \\[(?:\\-Werror,)?\\-Wc99\\-extensions[^\\]]*\\]";

local Eb=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-template[^\\]]*\\]";

local Fb="microsoft-exception-spec";

local Gb="(?: \\[(?:\\-Werror)?[^\\]]*\\])?";

local Hb="c++1y-extensions";

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

local Kb="931fcd3ba011";

local Lb="#error";

local Mb="excess-initializers";

local Nb="c11-extensions";

local Pb="c++11-narrowing";

local Qb=" \\[(?:\\-Werror,)?\\-Wc2x\\-extensions[^\\]]*\\]";

local Rb=" \\[(?:\\-Werror,)?\\-Wc\\+\\+14\\-extensions[^\\]]*\\]";

local Sb="c++11-compat";

local Tb="c++11-compat-pedantic";

local Ub="7c11da0cfd33";

local Vb="[clang] New __attribute__((__clang_arm_mve_alias)).";

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

local Xb="clang/lib/Parse/ParseObjc.cpp";

local Yb="pointer-arith";

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

local ac="gcc-compat";

local bc="3dbcea8b957a";

local cc="c++0x-compat";

local dc="gnu-empty-struct";

local ec="comment";

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

local gc="missing-declarations";

local hc="gnu-pointer-arith";

local ic="gnu-folding-constant";

local jc="clang/lib/AST/ASTImporter.cpp";

local kc="clang/lib/Sema/SemaAccess.cpp";

local lc="gnu-designator";

local mc="dtor-name";

local nc="main";

local oc="unknown-pragmas";

local pc="clang/lib/Sema/DeclSpec.cpp";

local qc="implicit-function-declaration";

local rc="clang/lib/Lex/PPExpressions.cpp";

local sc="[c++20] Implement semantic restrictions for C++20 designated";

local tc="5030928d60a1";

local uc="variadic-macros";

local vc="clang/lib/Parse/ParseInit.cpp";

local wc="implicit";

local xc="Modules Issue";

local yc="1228d42ddab8";

local zc="clang/lib/Basic/DiagnosticIDs.cpp";

local Ac="[OpenMP][Part 2] Use reusable OpenMP context/traits handling";

local Bc=" \\[(?:\\-Werror,)?\\-Wc99\\-designator[^\\]]*\\]";

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

local Dc=" \\[(?:\\-Werror,)?\\-Wmicrosoft\\-exception\\-spec[^\\]]*\\]";

local Gc="clang/lib/Sema/SemaTemplateInstantiateDecl.cpp";

[e]="missing \'typename\' prior to dependent type template name \'AB\'",

[b]=t,

[h]=m,

[j]={{E,4153,"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();"}}

[e]="no type named A in B",

[b]=t,

[h]=m,

[j]={{w,813,"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,11058,"/// 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;"}}

[e]="no type named \'type\' in A; \'enable_if\' cannot be used to disable this declaration",

[b]=t,

[h]=m,

[j]={{Jb,11263,"/// 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,3941,"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,11053,"/// 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;"}}

[e]="failed requirement \'A\'; \'enable_if\' cannot be used to disable this declaration",

[b]=t,

[h]=m,

[j]={{Jb,11273,"/// 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,3958,"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,11046,"/// 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();"}}

[e]="typename specifier refers to non-type member A in B",

[b]=t,

[h]=m,

[j]={{E,11145,"/// 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,11151,"/// 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;"}}

[e]="typename specifier refers to non-type A",

[b]=t,

[h]=m,

[j]={{E,11146,"/// 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,11152,"/// 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;"}}

[f]="typename specifier refers to a non\\-type template",

[g]=q,

[h]=x,

[j]={{wb,2017,"/// 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();"}}

[e]="typename specifier refers to a dependent using declaration for a value A in B",

[b]=t,

[h]=m,

[j]={{E,11068,"/// 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;"}}

[f]="type name requires a specifier or qualifier",

[g]=q,

[h]=x,

[i]={B,1236199783,C},

[j]={{F,2658,"/// 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);"}}

[f]="universal character name refers to a control character",

[g]=q,

[h]=A,

[j]={{Z,3509,"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,684,"/// 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);"}}

[e]="character \'A\' cannot be specified by a universal character name",

[b]=t,

[h]=A,

[j]={{Z,3512,"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,677,"/// 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);"}}

[f]="incomplete universal character name",

[g]=q,

[h]=A,

[j]={{cb,523,"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,610,"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);"}}

[f]="invalid universal character",

[g]=q,

[h]=A,

[j]={{Z,3525,"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,662,"/// 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);"}}

[e]="unable to make temporary file: A",

[b]=t,

[h]=q,

[e]="unable to rename temporary \'A\' to output file \'B\': \'C\'",

[b]=t,

[h]=q,

[e]="A is unavailable",

[b]=t,

[h]=m,

[j]={{"clang/lib/ARCMigrate/TransAPIUses.cpp",90,"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",95,"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",220,"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",54,"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",391,"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,844,"bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {\n  if (DiagID == diag::err_unavailable || DiagID == diag::err_unavailable_message)"},{"clang/lib/Sema/SemaAvailability.cpp",447,"/// 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;"}}

[e]="A is unavailable in ARC",

[b]=t,

[h]="ARC Restrictions",

[j]={{"clang/lib/Sema/SemaAvailability.cpp",462,"/// 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;"}}

[e]="A is unavailable: B",

[b]=t,

[h]=m,

[j]={{"clang/lib/ARCMigrate/TransAPIUses.cpp",91,"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",96,"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",221,"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",55,"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",392,"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,845,"bool DiagnosticIDs::isUnrecoverable(unsigned DiagID) const {\n  if (DiagID == diag::err_unavailable || DiagID == diag::err_unavailable_message)"},{"clang/lib/Sema/SemaAvailability.cpp",449,"/// 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;"}}

[e]="A has unknown return type; cast the call to its declared return type",

[b]=t,

[h]=m,

[j]={{y,21484,"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,21488,"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;"}}

[e]="no known method ...; cast the message send to the method\'s return type",

[b]=t,

[h]=m,

[j]={{y,21494,"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();"}}

[e]="A has unknown type; cast it to its declared type to use it",

[b]=t,

[h]=m,

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

[e]="declaration of A is missing in B class",

[b]=t,

[h]=m,

[j]={{Zb,154,"/// 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();"}}

[e]="undeclared identifier A in destructor name",

[b]=t,

[h]=m,

[i]={yc,1576809732,Ac},

[j]={{V,438,"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();"}}

[e]="use of undeclared label A",

[b]=t,

[h]=m,

[i]={H,1237025389,I},

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

[e]="definition of class A must be available to use Objective-C ...",

[b]=t,

[h]=m,

[j]={{Zb,204,"/// 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,208,"/// 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;"}}

[e]="cannot find protocol declaration for A",

[b]=t,

[h]=m,

[i]={B,1236199783,C},

[j]={{ob,1331,"/// 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,1745,"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,1393,"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;"}}

[e]="cannot find protocol declaration for A; did you mean B?",

[b]=t,

[h]=m,

[j]={{ob,1326,"/// 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,1711,"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]);"}}

[e]="use of undeclared A",

[b]=t,

[h]=m,

[i]={H,1237025389,I},

[j]={{"clang/lib/Sema/SemaAttr.cpp",805,"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,2381,"/// 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,5162,"/// 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();"}}

[e]="module A does not depend on a module exporting \'B\'",

[b]=t,

[h]=A,

[j]={{"clang/lib/Lex/ModuleMap.cpp",540,"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;"}}

[e]="module A does not directly depend on a module exporting \'B\', which is part of indirectly-used module C",

[b]=t,

[h]=A,

[i]={M,1625925174,N},

[j]={{"clang/lib/Lex/ModuleMap.cpp",528,"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;"}}

[e]="use of undeclared A; did you mean B?",

[b]=t,

[h]=m,

[j]={{y,2382,"/// 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;"}}

[e]="use of undeclared identifier A",

[b]=t,

[h]=m,

[i]={H,1237025389,I},

[j]={{"clang/lib/Sema/SemaCUDA.cpp",56,"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",826,"/// 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,2376,"/// 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,1591,"/// 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,3053,"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,23037,"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();"}}

[e]="use of undeclared identifier A; did you mean B?",

[b]=t,

[h]=m,

[j]={{"clang/lib/Sema/SemaCXXScopeSpec.cpp",627,"/// 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,1009,"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,2377,"/// 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,3048,"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,23031,"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());"}}

[e]="cannot find interface declaration for A",

[b]=t,

[h]=m,

[i]={B,1236199783,C},

[j]={{ob,1845,"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,1941,"/// 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,1944,"/// 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,5106,"/// 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;"}}

[e]="cannot find interface declaration for A; did you mean B?",

[b]=t,

[h]=m,

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

[e]="cannot find interface declaration for A, superclass of B",

[b]=t,

[h]=m,

[i]={B,1236199783,C},

[j]={{ob,617,"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,2034,"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;"}}

[e]="cannot find interface declaration for A, superclass of B; did you mean C?",

[b]=t,

[h]=m,

[j]={{ob,563,"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);"}}

[e]="inline variable A is not defined",

[b]=t,

[h]=m,

[j]={{"clang/lib/Sema/Sema.cpp",915,"/// 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;"}}

[e]="... A is used but not defined in this translation unit, and cannot be defined in any other translation unit because its type does not have linkage",

[b]=t,

[h]=m,

[j]={{"clang/lib/Sema/Sema.cpp",885,"/// 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;"}}

[e]="cannot determine underlying type of incomplete enumeration type A",

[b]=t,

[h]=m,

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

[e]="invalid escape sequence \'A\' in an unevaluated string literal",

[b]=t,

[h]=A,

[i]={M,1625925174,N},

[j]={{cb,365,"/// 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);"}}

[f]="an unevaluated string literal cannot have an encoding prefix",

[g]=q,

[h]=A,

[i]={M,1625925174,N},

[j]={{cb,1953,"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);"}}

[f]="an unevaluated string literal cannot be a user\\-defined literal",

[g]=q,

[h]=A,

[i]={M,1625925174,N},

[j]={{cb,2047,"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);"}}

[e]="... contains an unexpanded parameter pack",

[b]=t,

[h]=m,

[j]={{"clang/lib/Sema/SemaTemplateVariadic.cpp",372,"/// 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();"}}

[f]="unexpected \'@\' in program",

[g]=q,

[h]=x,

[i]={B,1236199783,C},

[j]={{F,4694,"/// 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,107,"/// 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,2902,"ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {\n  default:\n    if (Tok.getIdentifierInfo() == nullptr)\n      return ExprError(Diag(AtLoc, diag::err_unexpected_at));"},{Xb,2928,"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,2932,"ExprResult Parser::ParseObjCAtExpression(SourceLocation AtLoc) {\n  default:\n    default: {\n      if (str) {\n      } else\n        return ExprError(Diag(AtLoc, diag::err_unexpected_at));"}}

[f]="unexpected \'\\:\' in nested name specifier; did you mean \'\\:\\:\'\\?",

[g]=q,

[h]=x,

[j]={{vb,406,"/// 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(), \"::\");"}}

[f]="friends can only be classes or functions",

[g]=q,

[h]=m,

[j]={{z,17499,"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);"}}

[e]="unexpected interface name A: expected expression",

[b]=t,

[h]=m,

[i]={H,1237025389,I},

[j]={{y,3301,"/// 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();"}}

[f]="module declaration can only appear at the top level",

[g]=q,

[h]=xc,

[j]={{wb,1025,"/// 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);"}}

[e]="unexpected namespace name A: expected expression",

[b]=t,