Module:ClangDiags/DiagsLongData2: Difference between revisions

local a="";

local b="commit";

local c="prefix";

local d="type";

local e="message";

local f="regex1";

local g="regex2";

local h="regex3";

local i="category";

local j="title";

local k="source";

local l="error: ";

local m="Error";

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

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

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

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

local s="Parse Issue";

local t="Lexical or Preprocessor Issue";

local u="clang/lib/Lex/ModuleMap.cpp";

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

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

local x="5a8987ca5113";

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

local z="b1c4d5507fad";

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

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

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

local D="Modules Issue";

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

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

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

local H="Fatal";

local I="fatal error: ";

local J="fatal error\\: ";

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

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

local M="95f50964fbf5";

local N="Implement P2361 Unevaluated string literals";

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

local P="clang/lib/AST/ODRDiagsEmitter.cpp";

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

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

local S="Lambda Issue";

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

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

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

local X="clang/lib/Sema/SemaModule.cpp";

local Y="Introduce -Wreserved-identifier";

local Z="b83b23275b74";

local ab="A has different definitions in different modules; first difference is ... found ...";

local bb="clang/lib/Serialization/ASTReader.cpp";

local cb="clang/lib/Sema/SemaCXXScopeSpec.cpp";

local db="clang/lib/Frontend/CompilerInstance.cpp";

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

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

local gb="f881267db9a9";

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

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

local jb="AST Deserialization Issue";

local kb="718292f260bf";

local lb="clang/lib/Sema/JumpDiagnostics.cpp";

local mb="Introduce basic support for parsing module map files.";

local nb="5e77d76c953d";

local ob="Basic support for Microsoft property declarations and";

local pb="clang/lib/Sema/SemaPseudoObject.cpp";

local qb="clang/lib/Frontend/FrontendAction.cpp";

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

local sb="Inline Assembly Issue";

local tb="Coroutines Issue";

local ub="Implement Attribute Target MultiVersioning";

local vb="[SYCL] Add sycl_kernel attribute for accelerated code outlining";

local wb="ec273d3e3a8c";

local xb="281d20b601c8";

local yb="c094e7dc4b3f";

local zb="Add a warning for not packing non-POD members in packed structs";

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

local Bb="clang/lib/Frontend/CompilerInvocation.cpp";

local Cb="f60dc3caa673";

local Db="clang/lib/Parse/ParseStmtAsm.cpp";

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

local Fb="clang/lib/Parse/ParseExpr.cpp";

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

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

local Jb="Improve diagnostics for ill-formed literal operator declarations.";

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

local Lb="Parse inferred submodules in module maps, track their contents in";

local Mb="c28aee6a51a9";

["err_friend_is_member"]={

[j]="friends cannot be members of the declaring class",

[c]=l,

[d]=m,

[e]="friends cannot be members of the declaring class",

[f]=n,

[g]="friends cannot be members of the declaring class",

[h]=a,

[i]=o,

[b]={"07e91c04ba33",1249524943,"First pass at friend semantics."},

[k]={{r,15055,"NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, MultiTemplateParamsArg TemplateParams) {\n  if ((SS.isInvalid() || !SS.isSet()) && (FunctionContainingLocalClass = cast<CXXRecordDecl>(CurContext)->isLocalClass())) {\n  } else if (SS.isInvalid() || !SS.isSet()) {\n  } else if (!SS.getScopeRep()->isDependent()) {\n    // C++ [class.friend]p1: A friend of a class is a function or\n    //  class that is not a member of the class . . .\n    if (DC->Equals(CurContext))\n      Diag(DS.getFriendSpecLoc(), getLangOpts().CPlusPlus11 ? diag::warn_cxx98_compat_friend_is_member : diag::err_friend_is_member);"}}

["err_friend_not_first_in_declaration"]={

[j]="\'friend\' must appear first in a non-function declaration",

[c]=l,

[d]=m,

[e]="\'friend\' must appear first in a non-function declaration",

[f]=n,

[g]="\'friend\' must appear first in a non\\-function declaration",

[h]=a,

[i]=o,

[b]={"a31a89a38e8a",1348104660,"Per C++11 [class.friend]p3, the \'friend\' keyword must appear first in a"},

[k]={{r,14683,"/// Perform semantic analysis of the given friend type declaration.\n///\n/// \\returns A friend declaration that.\nFriendDecl *Sema::CheckFriendTypeDecl(SourceLocation LocStart, SourceLocation FriendLoc, TypeSourceInfo *TSInfo) {\n  // C++03 [class.friend]p2:\n  //  An elaborated-type-specifier shall be used in a friend declaration\n  //  for a class.*\n  //\n  //  * The class-key of the elaborated-type-specifier is required.\n  if (!CodeSynthesisContexts.empty()) {\n  } else {\n    // C++11 [class.friend]p3:\n    //  A friend declaration that does not declare a function shall have one\n    //  of the following forms:\n    //    friend elaborated-type-specifier ;\n    //    friend simple-type-specifier ;\n    //    friend typename-specifier ;\n    if (getLangOpts().CPlusPlus11 && LocStart != FriendLoc)\n      Diag(FriendLoc, diag::err_friend_not_first_in_declaration) << T;"}}

["err_func_def_incomplete_result"]={

[j]="incomplete result type A in function definition",

[c]=l,

[d]=m,

[e]="incomplete result type %0 in function definition",

[f]=n,

[g]="incomplete result type (.*?) in function definition",

[h]=a,

[i]=o,

[b]={x,1237025389,w},

[k]={{p,13395,"Decl *Sema::ActOnStartOfFunctionDef(Scope *FnBodyScope, Decl *D, SkipBodyInfo *SkipBody, FnBodyKind BodyKind) {\n  if (!ResultType->isDependentType() && !ResultType->isVoidType() && !FD->isInvalidDecl() && BodyKind != FnBodyKind::Delete && (RequireCompleteType(FD->getLocation(), ResultType, diag::err_func_def_incomplete_result) || RequireNonAbstractType(FD->getLocation(), FD->getReturnType(), diag::err_abstract_type_in_decl, AbstractReturnType)))"},{hb,317,"/// ActOnStartOfObjCMethodDef - This routine sets up parameters; invisible\n/// and user declared, in the method definition\'s AST.\nvoid Sema::ActOnStartOfObjCMethodDef(Scope *FnBodyScope, Decl *D) {\n  if (!ResultType->isDependentType() && !ResultType->isVoidType() && !MDecl->isInvalidDecl() && RequireCompleteType(MDecl->getLocation(), ResultType, diag::err_func_def_incomplete_result))"}}

["err_func_def_no_params"]={

[j]="function definition does not declare parameters",

[c]=l,

[d]=m,

[e]="function definition does not declare parameters",

[f]=n,

[g]="function definition does not declare parameters",

[h]=a,

[i]=s,

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

[k]={{R,2551,"/// 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  // Check for a member function definition.\n  if (BitfieldSize.isUnset()) {\n    if (DefinitionKind != FunctionDefinitionKind::Declaration) {\n      if (!DeclaratorInfo.isFunctionDeclarator()) {\n        Diag(DeclaratorInfo.getIdentifierLoc(), diag::err_func_def_no_params);"}}

["err_func_returning_array_function"]={

[j]="function cannot return ... type A",

[c]=l,

[d]=m,

[e]="function cannot return %select{array|function}0 type %1",

[f]=n,

[g]="function cannot return (?:array|function) type (.*?)",

[h]=a,

[i]=o,

[b]={x,1237025389,w},

[k]={{q,18412,"/// Rebuilds a call expression which yielded __unknown_anytype.\nExprResult RebuildUnknownAnyExpr::VisitCallExpr(CallExpr *E) {\n  // Verify that this is a legal result type of a function.\n  if (DestType->isArrayType() || DestType->isFunctionType()) {\n    unsigned diagID = diag::err_func_returning_array_function;"},{q,18489,"ExprResult RebuildUnknownAnyExpr::VisitObjCMessageExpr(ObjCMessageExpr *E) {\n  // Verify that this is a legal result type of a call.\n  if (DestType->isArrayType() || DestType->isFunctionType()) {\n    S.Diag(E->getExprLoc(), diag::err_func_returning_array_function) << DestType->isFunctionType() << DestType;"},{F,2551,"bool Sema::CheckFunctionReturnType(QualType T, SourceLocation Loc) {\n  if (T->isArrayType() || T->isFunctionType()) {\n    Diag(Loc, diag::err_func_returning_array_function) << T->isFunctionType() << T;"},{F,4647,"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      // C99 6.7.5.3p1: The return type may not be a function or array type.\n      // For conversion functions, we\'ll diagnose this particular error later.\n      if (!D.isInvalidType() && (T->isArrayType() || T->isFunctionType()) && (D.getName().getKind() != UnqualifiedIdKind::IK_ConversionFunctionId)) {\n        unsigned diagID = diag::err_func_returning_array_function;"}}

["err_func_returning_qualified_void"]={

[c]="warning: ",

[d]="Warning",

["groups"]={"qualified-void-return-type"},

["maingroup"]="qualified-void-return-type",

[e]="function cannot return qualified void type %0",

[f]="(?:warning|error|fatal error)\\: ",

[g]="function cannot return qualified void type (.*?)",

[h]=" \\[(?:\\-Werror,)?\\-Wqualified\\-void\\-return\\-type[^\\]]*\\]",

[i]=o,

[b]={"c116802ef387",1421340353,"PR 20146"},

[k]={{F,4722,"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      // cv-qualifiers on return types are pointless except when the type is a\n      // class type in C++.\n      if ((T.getCVRQualifiers() || T->isAtomicType()) && !(S.getLangOpts().CPlusPlus && (T->isDependentType() || T->isRecordType()))) {\n        if (T->isVoidType() && !S.getLangOpts().CPlusPlus && D.getFunctionDefinitionKind() == FunctionDefinitionKind::Definition) {\n          S.Diag(DeclType.Loc, diag::err_func_returning_qualified_void) << T;"}}

["err_function_attribute_mismatch"]={

[j]="function declared with A attribute was previously declared without the B attribute",

[c]=l,

[d]=m,

[e]="function declared with %0 attribute was previously declared without the %0 attribute",

[f]=n,

[g]="function declared with (.*?) attribute was previously declared without the (.*?) attribute",

[h]=a,

[i]=o,

[b]={"318a6eae06dd",1493294460,"[X86] Support of no_caller_saved_registers attribute"},

[k]={{p,3454,"/// 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  // Merge ns_returns_retained attribute.\n  if (OldTypeInfo.getProducesResult() != NewTypeInfo.getProducesResult()) {\n    if (NewTypeInfo.getProducesResult()) {\n      Diag(New->getLocation(), diag::err_function_attribute_mismatch) << \"\'ns_returns_retained\'\";"},{p,3466,"/// 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 (OldTypeInfo.getNoCallerSavedRegs() != NewTypeInfo.getNoCallerSavedRegs()) {\n    if (NewTypeInfo.getNoCallerSavedRegs()) {\n      Diag(New->getLocation(), diag::err_function_attribute_mismatch) << Attr;"}}

["err_function_decl_cmse_ns_call"]={

[j]="functions may not be declared with \'cmse_nonsecure_call\' attribute",

[c]=l,

[d]=m,

[e]="functions may not be declared with \'cmse_nonsecure_call\' attribute",

[f]=n,

[g]="functions may not be declared with \'cmse_nonsecure_call\' attribute",

[h]=a,

[i]=o,

[b]={T,1576908663,U},

[k]={{p,8490,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (R.getCanonicalType()->castAs<FunctionType>()->getCmseNSCallAttr())\n    Diag(D.getIdentifierLoc(), diag::err_function_decl_cmse_ns_call);"}}

["err_function_declared_typedef"]={

[j]="function definition declared \'typedef\'",

[c]=l,

[d]=m,

[e]="function definition declared \'typedef\'",

[f]=n,

[g]="function definition declared \'typedef\'",

[h]=a,

[i]=s,

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

[k]={{C,1980,"/// 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    // Look at the next token to make sure that this isn\'t a function\n    // declaration.  We have to check this because __attribute__ might be the\n    // start of a function definition in GCC-extended K&R C.\n    if (!isDeclarationAfterDeclarator()) {\n      // Function definitions are only allowed at file scope and in C++ classes.\n      // The C++ inline method definition case is handled elsewhere, so we only\n      // need to handle the file scope definition case.\n      if (Context == DeclaratorContext::File) {\n        if (isStartOfFunctionDefinition(D)) {\n          if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {\n            Diag(Tok, diag::err_function_declared_typedef);"},{R,2562,"/// 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  // Check for a member function definition.\n  if (BitfieldSize.isUnset()) {\n    if (DefinitionKind != FunctionDefinitionKind::Declaration) {\n      if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {\n        Diag(DeclaratorInfo.getIdentifierLoc(), diag::err_function_declared_typedef);"},{"clang/lib/Parse/ParseTemplate.cpp",284,"/// Parse a single declaration that declares a template,\n/// template specialization, or explicit instantiation of a template.\n///\n/// \\param DeclEnd will receive the source location of the last token\n/// within this declaration.\n///\n/// \\param AS the access specifier associated with this\n/// declaration. Will be AS_none for namespace-scope declarations.\n///\n/// \\returns the new declaration.\nDecl *Parser::ParseSingleDeclarationAfterTemplate(DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject &DiagsFromTParams, SourceLocation &DeclEnd, ParsedAttributes &AccessAttrs, AccessSpecifier AS) {\n  if (DeclaratorInfo.isFunctionDeclarator() && isStartOfFunctionDefinition(DeclaratorInfo)) {\n    if (DS.getStorageClassSpec() == DeclSpec::SCS_typedef) {\n      Diag(DS.getStorageClassSpecLoc(), diag::err_function_declared_typedef) << FixItHint::CreateRemoval(DS.getStorageClassSpecLoc());"}}

["err_function_definition_not_allowed"]={

[j]="function definition is not allowed here",

[c]=l,

[d]=m,

[e]="function definition is not allowed here",

[f]=n,

[g]="function definition is not allowed here",

[h]=a,

[i]=s,

[b]={"012efe22bcf4",1366128092,"Fix PR4296: Add parser detection/error recovery for nested functions, from Serve Pavlov!"},

[k]={{C,2006,"/// 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    // Look at the next token to make sure that this isn\'t a function\n    // declaration.  We have to check this because __attribute__ might be the\n    // start of a function definition in GCC-extended K&R C.\n    if (!isDeclarationAfterDeclarator()) {\n      // Function definitions are only allowed at file scope and in C++ classes.\n      // The C++ inline method definition case is handled elsewhere, so we only\n      // need to handle the file scope definition case.\n      if (Context == DeclaratorContext::File) {\n      } else {\n        if (Tok.is(tok::l_brace)) {\n          Diag(Tok, diag::err_function_definition_not_allowed);"},{"clang/lib/Parse/ParseTemplate.cpp",275,"/// Parse a single declaration that declares a template,\n/// template specialization, or explicit instantiation of a template.\n///\n/// \\param DeclEnd will receive the source location of the last token\n/// within this declaration.\n///\n/// \\param AS the access specifier associated with this\n/// declaration. Will be AS_none for namespace-scope declarations.\n///\n/// \\returns the new declaration.\nDecl *Parser::ParseSingleDeclarationAfterTemplate(DeclaratorContext Context, const ParsedTemplateInfo &TemplateInfo, ParsingDeclRAIIObject &DiagsFromTParams, SourceLocation &DeclEnd, ParsedAttributes &AccessAttrs, AccessSpecifier AS) {\n  if (DeclaratorInfo.isFunctionDeclarator() && isStartOfFunctionDefinition(DeclaratorInfo)) {\n    // Function definitions are only allowed at file scope and in C++ classes.\n    // The C++ inline method definition case is handled elsewhere, so we only\n    // need to handle the file scope definition case.\n    if (Context != DeclaratorContext::File) {\n      Diag(Tok, diag::err_function_definition_not_allowed);"}}

["err_function_is_not_record"]={

[j]="unexpected A in function call; perhaps remove the B?",

[c]=l,

[d]=m,

[e]="unexpected %0 in function call; perhaps remove the %0?",

[f]=n,

[g]="unexpected (.*?) in function call; perhaps remove the (.*?)\\?",

[h]=a,

[i]=s,

[b]={"638264ea2a3d",1373665382,"Provide a better diagnostic and a fixit for a \'.\' or \'->\' before the left paren"},

[k]={{Fb,1968,"/// Once the leading part of a postfix-expression is parsed, this\n/// method parses any suffixes that apply.\n///\n/// \\verbatim\n///      postfix-expression: [C99 6.5.2]\n///        primary-expression\n///        postfix-expression \'[\' expression \']\'\n///        postfix-expression \'[\' braced-init-list \']\'\n///        postfix-expression \'[\' expression-list [opt] \']\' [C++23 12.4.5]\n///        postfix-expression \'(\' argument-expression-list[opt] \')\'\n///        postfix-expression \'.\' identifier\n///        postfix-expression \'->\' identifier\n///        postfix-expression \'++\'\n///        postfix-expression \'--\'\n///        \'(\' type-name \')\' \'{\' initializer-list \'}\'\n///        \'(\' type-name \')\' \'{\' initializer-list \',\' \'}\'\n///\n///      argument-expression-list: [C99 6.5.2]\n///        argument-expression ...[opt]\n///        argument-expression-list \',\' assignment-expression ...[opt]\n/// \\endverbatim\nExprResult Parser::ParsePostfixExpressionSuffix(ExprResult LHS) {\n  while (true) {\n    case tok::period: {\n      if (getLangOpts().CPlusPlus && !LHS.isInvalid()) {\n        if (BaseType && Tok.is(tok::l_paren) && (BaseType->isFunctionType() || BaseType->isSpecificPlaceholderType(BuiltinType::BoundMember))) {\n          Diag(OpLoc, diag::err_function_is_not_record) << OpKind << Base->getSourceRange() << FixItHint::CreateRemoval(OpLoc);"}}

["err_function_marked_override_not_overriding"]={

[j]="A marked \'override\' but does not override any member functions",

[c]=l,

[d]=m,

[e]="%0 marked \'override\' but does not override any member functions",

[f]=n,

[g]="(.*?) marked \'override\' but does not override any member functions",

[h]=a,

[i]=o,

[b]={"fd8355373333",1295503034,"Diagnose virtual member functions marked override but not overriding any virtual member functions."},

[k]={{r,2793,"/// CheckOverrideControl - Check C++11 override control semantics.\nvoid Sema::CheckOverrideControl(NamedDecl *D) {\n  if (MD->hasAttr<OverrideAttr>() && !HasOverriddenMethods)\n    Diag(MD->getLocation(), diag::err_function_marked_override_not_overriding) << MD->getDeclName();"}}

["err_function_needs_feature"]={

[j]="always_inline function A requires target feature \'B\', but would be inlined into function C that is compiled without support for \'D\'",

[c]=l,

[d]=m,

[e]="always_inline function %1 requires target feature \'%2\', but would be inlined into function %0 that is compiled without support for \'%2\'",

[f]=n,

[g]="always_inline function (.*?) requires target feature \'(.*?)\', but would be inlined into function (.*?) that is compiled without support for \'(.*?)\'",

[h]=a,

[i]=a,

[b]={"2b2d56f059e7",1447289052,"Provide a frontend based error for always_inline functions that require"},

[k]={{"clang/lib/CodeGen/CodeGenFunction.cpp",2344,"// Emits an error if we don\'t have a valid set of target features for the\n// called function.\nvoid CodeGenFunction::checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl) {\n  if (BuiltinID) {\n  } else if (!TargetDecl->isMultiVersion() && TargetDecl->hasAttr<TargetAttr>()) {\n    if (!llvm::all_of(ReqFeatures, [&](StringRef Feature) {\n      CGM.getDiags().Report(Loc, diag::err_function_needs_feature) << FD->getDeclName() << TargetDecl->getDeclName() << MissingFeature;"},{"clang/lib/CodeGen/CodeGenFunction.cpp",2351,"// Emits an error if we don\'t have a valid set of target features for the\n// called function.\nvoid CodeGenFunction::checkTargetFeatures(SourceLocation Loc, const FunctionDecl *TargetDecl) {\n  if (BuiltinID) {\n  } else if (!TargetDecl->isMultiVersion() && TargetDecl->hasAttr<TargetAttr>()) {\n  } else if (!FD->isMultiVersion() && FD->hasAttr<TargetAttr>()) {\n    for (const auto &F : CalleeFeatureMap) {\n      if (F.getValue() && (!CallerFeatureMap.lookup(F.getKey()) || !CallerFeatureMap.find(F.getKey())->getValue()))\n        CGM.getDiags().Report(Loc, diag::err_function_needs_feature) << FD->getDeclName() << TargetDecl->getDeclName() << F.getKey();"}}

["err_function_parameter_pack_without_parameter_packs"]={

[j]="type A of function parameter pack does not contain any unexpanded parameter packs",

[c]=l,

[d]=m,

[e]="type %0 of function parameter pack does not contain any unexpanded parameter packs",

[f]=n,

[g]="type (.*?) of function parameter pack does not contain any unexpanded parameter packs",

[k]={{"clang/lib/Sema/SemaTemplateInstantiate.cpp",2127,"ParmVarDecl *Sema::SubstParmVarDecl(ParmVarDecl *OldParm, const MultiLevelTemplateArgumentList &TemplateArgs, int indexAdjustment, std::optional<unsigned> NumExpansions, bool ExpectParameterPack, bool EvaluateConstraint) {\n  if (PackExpansionTypeLoc ExpansionTL = OldTL.getAs<PackExpansionTypeLoc>()) {\n    if (NewDI->getType()->containsUnexpandedParameterPack()) {\n    } else if (ExpectParameterPack) {\n      Diag(OldParm->getLocation(), diag::err_function_parameter_pack_without_parameter_packs) << NewDI->getType();"},{F,5205,"static TypeSourceInfo *GetFullTypeForDeclarator(TypeProcessingState &state, QualType declSpecType, TypeSourceInfo *TInfo) {\n  // If there was an ellipsis in the declarator, the declaration declares a\n  // parameter pack whose type may be a pack expansion type.\n  if (D.hasEllipsis()) {\n    case DeclaratorContext::RequiresExpr:\n      // C++0x [dcl.fct]p13:\n      //  [...] When it is part of a parameter-declaration-clause, the\n      //  parameter pack is a function parameter pack (14.5.3). The type T\n      //  of the declarator-id of the function parameter pack shall contain\n      //  a template parameter pack; each template parameter pack in T is\n      //  expanded by the function parameter pack.\n      //\n      // We represent function parameter packs as function parameters whose\n      // type is a pack expansion.\n      if (!T->containsUnexpandedParameterPack() && (!LangOpts.CPlusPlus20 || !T->getContainedAutoType())) {\n        S.Diag(D.getEllipsisLoc(), diag::err_function_parameter_pack_without_parameter_packs) << T << D.getSourceRange();"}}

["err_function_scope_depth_exceeded"]={

[j]="function scope depth exceeded maximum of A",

[c]=I,

[d]=H,

[e]="function scope depth exceeded maximum of %0",

[f]=J,

[g]="function scope depth exceeded maximum of (.*?)",

[h]=a,

[i]=s,

[b]={"739b410f1ff5",1570627358,"Add a warning, flags and pragmas to limit the number of pre-processor tokens in a translation unit"},

[k]={{C,6591,"/// ParseParameterDeclarationClause - Parse a (possibly empty) parameter-list\n/// after the opening parenthesis. This function will not parse a K&R-style\n/// identifier list.\n///\n/// DeclContext is the context of the declarator being parsed.  If FirstArgAttrs\n/// is non-null, then the caller parsed those attributes immediately after the\n/// open paren - they will be applied to the DeclSpec of the first parameter.\n///\n/// After returning, ParamInfo will hold the parsed parameters. EllipsisLoc will\n/// be the location of the ellipsis, if any was parsed.\n///\n///      parameter-type-list: [C99 6.7.5]\n///        parameter-list\n///        parameter-list \',\' \'...\'\n/// [C++]  parameter-list \'...\'\n///\n///      parameter-list: [C99 6.7.5]\n///        parameter-declaration\n///        parameter-list \',\' parameter-declaration\n///\n///      parameter-declaration: [C99 6.7.5]\n///        declaration-specifiers declarator\n/// [C++]  declaration-specifiers declarator \'=\' assignment-expression\n/// [C++11]                                      initializer-clause\n/// [GNU]  declaration-specifiers declarator attributes\n///        declaration-specifiers abstract-declarator[opt]\n/// [C++]  declaration-specifiers abstract-declarator[opt]\n///          \'=\' assignment-expression\n/// [GNU]  declaration-specifiers abstract-declarator[opt] attributes\n/// [C++11] attribute-specifier-seq parameter-declaration\n///\nvoid Parser::ParseParameterDeclarationClause(DeclaratorContext DeclaratorCtx, ParsedAttributes &FirstArgAttrs, SmallVectorImpl<DeclaratorChunk::ParamInfo> &ParamInfo, SourceLocation &EllipsisLoc, bool IsACXXFunctionDeclaration) {\n  // Avoid exceeding the maximum function scope depth.\n  // See https://bugs.llvm.org/show_bug.cgi?id=19607\n  // Note Sema::ActOnParamDeclarator calls ParmVarDecl::setScopeInfo with\n  // getFunctionPrototypeDepth() - 1.\n  if (getCurScope()->getFunctionPrototypeDepth() - 1 > ParmVarDecl::getMaxFunctionScopeDepth()) {\n    Diag(Tok.getLocation(), diag::err_function_scope_depth_exceeded) << ParmVarDecl::getMaxFunctionScopeDepth();"}}

["err_function_start_invalid_type"]={

[j]="argument must be a function",

[c]=l,

[d]=m,

[e]="argument must be a function",

[f]=n,

[g]="argument must be a function",

[h]=a,

[i]=o,

[b]={"f9c3310d32c6",1616787805,"[OPENMP]Fix PR49366: crash on VLAs in task untied regions."},

[k]={{y,239,"/// Check that the argument to __builtin_function_start is a function.\nstatic bool SemaBuiltinFunctionStart(Sema &S, CallExpr *TheCall) {\n  if (!FD) {\n    S.Diag(TheCall->getBeginLoc(), diag::err_function_start_invalid_type) << TheCall->getSourceRange();"}}

["err_function_template_partial_spec"]={

[j]="function template partial specialization is not allowed",

[c]=l,

[d]=m,

[e]="function template partial specialization is not allowed",

[f]=n,

[g]="function template partial specialization is not allowed",

[h]=a,

[i]=o,

[b]={"a5f6f9c7a1bb",1295895279,"Disallow function template partial specializations, from Hans"},

[k]={{p,9069,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (!getLangOpts().CPlusPlus) {\n  } else {\n    // If the declarator is a template-id, translate the parser\'s template\n    // argument list into our AST format.\n    if (D.getName().getKind() == UnqualifiedIdKind::IK_TemplateId) {\n      if (NewFD->isInvalidDecl()) {\n      } else if (FunctionTemplate) {\n        Diag(D.getIdentifierLoc(), diag::err_function_template_partial_spec) << SourceRange(TemplateId->LAngleLoc, TemplateId->RAngleLoc);"}}

["err_function_template_spec_ambiguous"]={

[j]="function template specialization A ambiguously refers to more than one function template; explicitly specify... template arguments to identify a particular function template",

[c]=l,

[d]=m,

[e]="function template specialization %0 ambiguously refers to more than one function template; explicitly specify%select{| additional}1 template arguments to identify a particular function template",

[f]=n,

[g]="function template specialization (.*?) ambiguously refers to more than one function template; explicitly specify(?:| additional) template arguments to identify a particular function template",

[h]=a,

[i]=o,

[b]={"3a923c2d3799",1253834087,"WIP implementation of explicit function template specialization. This"},

[k]={{K,7812,"/// Perform semantic analysis for the given function template\n/// specialization.\n///\n/// This routine performs all of the semantic analysis required for an\n/// explicit function template specialization. On successful completion,\n/// the function declaration \\p FD will become a function template\n/// specialization.\n///\n/// \\param FD the function declaration, which will be updated to become a\n/// function template specialization.\n///\n/// \\param ExplicitTemplateArgs the explicitly-provided template arguments,\n/// if any. Note that this may be valid info even when 0 arguments are\n/// explicitly provided as in, e.g., \\c void sort<>(char*, char*);\n/// as it anyway contains info on the angle brackets locations.\n///\n/// \\param Previous the set of declarations that may be specialized by\n/// this function specialization.\n///\n/// \\param QualifiedFriend whether this is a lookup for a qualified friend\n/// declaration with no explicit template argument list that might be\n/// befriending a function template specialization.\nbool Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend) {\n  UnresolvedSetIterator Result = getMostSpecialized(Candidates.begin(), Candidates.end(), FailedCandidates, FD->getLocation(), PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(), PDiag(diag::err_function_template_spec_ambiguous) << FD->getDeclName() << (ExplicitTemplateArgs != nullptr), PDiag(diag::note_function_template_spec_matched));"}}

["err_function_template_spec_no_match"]={

[j]="no function template matches function template specialization A",

[c]=l,

[d]=m,

[e]="no function template matches function template specialization %0",

[f]=n,

[g]="no function template matches function template specialization (.*?)",

[h]=a,

[i]=o,

[b]={"3a923c2d3799",1253834087,"WIP implementation of explicit function template specialization. This"},

[k]={{K,7812,"/// Perform semantic analysis for the given function template\n/// specialization.\n///\n/// This routine performs all of the semantic analysis required for an\n/// explicit function template specialization. On successful completion,\n/// the function declaration \\p FD will become a function template\n/// specialization.\n///\n/// \\param FD the function declaration, which will be updated to become a\n/// function template specialization.\n///\n/// \\param ExplicitTemplateArgs the explicitly-provided template arguments,\n/// if any. Note that this may be valid info even when 0 arguments are\n/// explicitly provided as in, e.g., \\c void sort<>(char*, char*);\n/// as it anyway contains info on the angle brackets locations.\n///\n/// \\param Previous the set of declarations that may be specialized by\n/// this function specialization.\n///\n/// \\param QualifiedFriend whether this is a lookup for a qualified friend\n/// declaration with no explicit template argument list that might be\n/// befriending a function template specialization.\nbool Sema::CheckFunctionTemplateSpecialization(FunctionDecl *FD, TemplateArgumentListInfo *ExplicitTemplateArgs, LookupResult &Previous, bool QualifiedFriend) {\n  UnresolvedSetIterator Result = getMostSpecialized(Candidates.begin(), Candidates.end(), FailedCandidates, FD->getLocation(), PDiag(diag::err_function_template_spec_no_match) << FD->getDeclName(), PDiag(diag::err_function_template_spec_ambiguous) << FD->getDeclName() << (ExplicitTemplateArgs != nullptr), PDiag(diag::note_function_template_spec_matched));"}}

["err_gc_weak_property_strong_type"]={

[j]="weak attribute declared on a __strong type property in GC mode",

[c]=l,

[d]=m,

[e]="weak attribute declared on a __strong type property in GC mode",

[f]=n,

[g]="weak attribute declared on a __strong type property in GC mode",

[h]=a,

[i]=o,

[b]={"eebdb67420c1",1315412661,"objc-gc: More sema work for properties declared \'weak\'"},

[k]={{Gb,1022,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  // Check that we have a valid, previously declared ivar for @synthesize\n  if (Synthesize) {\n    if (kind & ObjCPropertyAttribute::kind_weak) {\n      // Add GC __weak to the ivar type if the property is weak.\n      if (getLangOpts().getGC() != LangOptions::NonGC) {\n        if (PropertyIvarType.isObjCGCStrong()) {\n          Diag(PropertyDiagLoc, diag::err_gc_weak_property_strong_type);"}}

["err_generic_sel_multi_match"]={

[j]="controlling expression type A compatible with B generic association types",

[c]=l,

[d]=m,

[e]="controlling expression type %0 compatible with %1 generic association types",

[f]=n,

[g]="controlling expression type (.*?) compatible with (.*?) generic association types",

[h]=a,

[i]=o,

[b]={"91147596414d",1302827748,"C1X: implement generic selections"},

[k]={{q,1591,"ExprResult Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef<TypeSourceInfo *> Types, ArrayRef<Expr *> Exprs) {\n  // C11 6.5.1.1p2 \"The controlling expression of a generic selection shall have\n  // type compatible with at most one of the types named in its generic\n  // association list.\"\n  if (CompatIndices.size() > 1) {\n    Diag(SR.getBegin(), diag::err_generic_sel_multi_match) << SR << P.second << (unsigned)CompatIndices.size();"}}

["err_generic_sel_no_match"]={

[j]="controlling expression type A not compatible with any generic association type",

[c]=l,

[d]=m,

[e]="controlling expression type %0 not compatible with any generic association type",

[f]=n,

[g]="controlling expression type (.*?) not compatible with any generic association type",

[h]=a,

[i]=o,

[b]={"91147596414d",1302827748,"C1X: implement generic selections"},

[k]={{q,1604,"ExprResult Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef<TypeSourceInfo *> Types, ArrayRef<Expr *> Exprs) {\n  // C11 6.5.1.1p2 \"If a generic selection has no default generic association,\n  // its controlling expression shall have type compatible with exactly one of\n  // the types named in its generic association list.\"\n  if (DefaultIndex == -1U && CompatIndices.size() == 0) {\n    Diag(SR.getBegin(), diag::err_generic_sel_no_match) << SR << P.second;"}}

["err_getter_not_found"]={

[j]="no getter method for read from property",

[c]=l,

[d]=m,

[e]="no getter method for read from property",

[f]=n,

[g]="no getter method for read from property",

[h]=a,

[i]=o,

[b]={"0f0b302ffe8e",1293047195,"Complain on missing property getter method only"},

[k]={{pb,688,"/// @property-specific behavior for doing lvalue-to-rvalue conversion.\nExprResult ObjCPropertyOpBuilder::buildRValueOperation(Expr *op) {\n  // Explicit properties always have getters, but implicit ones don\'t.\n  // Check that before proceeding.\n  if (RefExpr->isImplicitProperty() && !RefExpr->getImplicitPropertyGetter()) {\n    S.Diag(RefExpr->getLocation(), diag::err_getter_not_found) << RefExpr->getSourceRange();"}}

["err_global_asm_qualifier_ignored"]={

[j]="meaningless \'A\' on asm outside function",

[c]=l,

[d]=m,

[e]="meaningless \'%0\' on asm outside function",

[f]=n,

[g]="meaningless \'(.*?)\' on asm outside function",

[h]=a,

[i]=sb,

[b]={"f08df464ae89",1582039343,"[OPENMP50]Add initial support for OpenMP 5.0 iterator."},

[k]={{Q,1509,"/// ParseSimpleAsm\n///\n/// [GNU] simple-asm-expr:\n///        \'asm\' \'(\' asm-string-literal \')\'\n///\nExprResult Parser::ParseSimpleAsm(bool ForAsmLabel, SourceLocation *EndLoc) {\n  if (isGNUAsmQualifier(Tok)) {\n    Diag(Tok, diag::err_global_asm_qualifier_ignored) << GNUAsmQualifiers::getQualifierName(getGNUAsmQualifier(Tok)) << FixItHint::CreateRemoval(RemovalRange);"}}

["err_global_call_not_config"]={

[j]="call to global function A not configured",

[c]=l,

[d]=m,

[e]="call to global function %0 not configured",

[f]=n,

[g]="call to global function (.*?) not configured",

[h]=a,

[i]=o,

[b]={"34a20b081e43",1317599355,"CUDA: diagnose unconfigured calls to global functions"},

[k]={{q,6459,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy.  The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n  if (getLangOpts().CUDA) {\n    if (Config) {\n    } else {\n      // CUDA: Calls to global functions must be configured\n      if (FDecl && FDecl->hasAttr<CUDAGlobalAttr>())\n        return ExprError(Diag(LParenLoc, diag::err_global_call_not_config) << FDecl << Fn->getSourceRange());"}}

["err_global_module_introducer_not_at_start"]={

[j]="\'module;\' introducing a global module fragment can appear only at the start of the translation unit",

[c]=l,

[d]=m,

[e]="\'module;\' introducing a global module fragment can appear only at the start of the translation unit",

[f]=n,

[g]="\'module;\' introducing a global module fragment can appear only at the start of the translation unit",

[h]=a,

[i]=D,

[b]={"d652bdd05f1c",1555229219,"[c++20] Parsing support for module-declarations, import-declarations,"},

[k]={{Q,2178,"/// Parse a declaration beginning with the \'module\' keyword or C++20\n/// context-sensitive keyword (optionally preceded by \'export\').\n///\n///  module-declaration:  [C++20]\n///    \'export\'[opt] \'module\' module-name attribute-specifier-seq[opt] \';\'\n///\n///  global-module-fragment:  [C++2a]\n///    \'module\' \';\' top-level-declaration-seq[opt]\n///  module-declaration:      [C++2a]\n///    \'export\'[opt] \'module\' module-name module-partition[opt]\n///            attribute-specifier-seq[opt] \';\'\n///  private-module-fragment: [C++2a]\n///    \'module\' \':\' \'private\' \';\' top-level-declaration-seq[opt]\nParser::DeclGroupPtrTy Parser::ParseModuleDecl(Sema::ModuleImportState &ImportState) {\n  // Parse a global-module-fragment, if present.\n  if (getLangOpts().CPlusPlusModules && Tok.is(tok::semi)) {\n    if (ImportState != Sema::ModuleImportState::FirstDecl) {\n      Diag(StartLoc, diag::err_global_module_introducer_not_at_start) << SourceRange(StartLoc, SemiLoc);"}}

["err_gnu_inline_asm_disabled"]={

[j]="GNU-style inline assembly is disabled",

[c]=l,

[d]=m,

[e]="GNU-style inline assembly is disabled",

[f]=n,

[g]="GNU\\-style inline assembly is disabled",

[h]=a,

[i]=sb,

[b]={"cb0d13fc2337",1421449528,"Adding option -fno-inline-asm to disallow inline asm"},

[k]={{Q,835,"/// 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_asm: {\n    // Check if GNU-style InlineAsm is disabled.\n    // Empty asm string is allowed because it will not introduce\n    // any assembly code.\n    if (!(getLangOpts().GNUAsm || Result.isInvalid())) {\n      if (!SL->getString().trim().empty())\n        Diag(StartLoc, diag::err_gnu_inline_asm_disabled);"},{Db,675,"/// ParseAsmStatement - Parse a GNU extended asm statement.\n///      asm-statement:\n///        gnu-asm-statement\n///        ms-asm-statement\n///\n/// [GNU] gnu-asm-statement:\n///        \'asm\' asm-qualifier-list[opt] \'(\' asm-argument \')\' \';\'\n///\n/// [GNU] asm-argument:\n///        asm-string-literal\n///        asm-string-literal \':\' asm-operands[opt]\n///        asm-string-literal \':\' asm-operands[opt] \':\' asm-operands[opt]\n///        asm-string-literal \':\' asm-operands[opt] \':\' asm-operands[opt]\n///                \':\' asm-clobbers\n///\n/// [GNU] asm-clobbers:\n///        asm-string-literal\n///        asm-clobbers \',\' asm-string-literal\n///\nStmtResult Parser::ParseAsmStatement(bool &msAsm) {\n  // Check if GNU-style InlineAsm is disabled.\n  // Error on anything other than empty string.\n  if (!(getLangOpts().GNUAsm || AsmString.isInvalid())) {\n    if (!SL->getString().trim().empty())\n      Diag(Loc, diag::err_gnu_inline_asm_disabled);"}}

["err_goto_into_protected_scope"]={

[j]="cannot jump from this goto statement to its label",

[c]=l,

[d]=m,

[e]="cannot jump from this goto statement to its label",

[f]=n,

[g]="cannot jump from this goto statement to its label",

[h]=a,

[i]=o,

[b]={"960cc525ec72",1240047387,"rewrite the goto scope checking code to be more efficient, simpler,"},

[k]={{lb,599,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    // With a goto,\n    if (GotoStmt *GS = dyn_cast<GotoStmt>(Jump)) {\n      // The label may not have a statement if it\'s coming from inline MS ASM.\n      if (GS->getLabel()->getStmt()) {\n        CheckJump(GS, GS->getLabel()->getStmt(), GS->getGotoLoc(), diag::err_goto_into_protected_scope, diag::ext_goto_into_protected_scope, diag::warn_cxx98_compat_goto_into_protected_scope);"},{lb,624,"/// VerifyJumps - Verify each element of the Jumps array to see if they are\n/// valid, emitting diagnostics if not.\nvoid JumpScopeChecker::VerifyJumps() {\n  while (!Jumps.empty()) {\n    // We only get indirect gotos here when they have a constant target.\n    if (IndirectGotoStmt *IGS = dyn_cast<IndirectGotoStmt>(Jump)) {\n      CheckJump(IGS, Target->getStmt(), IGS->getGotoLoc(), diag::err_goto_into_protected_scope, diag::ext_goto_into_protected_scope, diag::warn_cxx98_compat_goto_into_protected_scope);"},{lb,774,"static bool IsMicrosoftJumpWarning(unsigned JumpDiag, unsigned InDiagNote) { return (JumpDiag == diag::err_goto_into_protected_scope && (InDiagNote == diag::note_protected_by_variable_init || InDiagNote == diag::note_protected_by_variable_nontriv_destructor)); }"},{lb,859,"/// CheckJump - Validate that the specified jump statement is valid: that it is\n/// jumping within or out of its current scope, not into a deeper one.\nvoid JumpScopeChecker::CheckJump(Stmt *From, Stmt *To, SourceLocation DiagLoc, unsigned JumpDiagError, unsigned JumpDiagWarning, unsigned JumpDiagCXX98Compat) {\n  // Warn on gotos out of __finally blocks.\n  if (isa<GotoStmt>(From) || isa<IndirectGotoStmt>(From)) {\n    // If FromScope > ToScope, FromScope is more nested and the jump goes to a\n    // less nested scope.  Check if it crosses a __finally along the way.\n    for (unsigned I = FromScope; I > ToScope; I = Scopes[I].ParentScope) {\n      if (Scopes[I].InDiag == diag::note_omp_protected_structured_block) {\n        S.Diag(From->getBeginLoc(), diag::err_goto_into_protected_scope);"}}

["err_goto_ms_asm_label"]={

[j]="cannot jump from this goto statement to label A inside an inline assembly block",

[c]=l,

[d]=m,

[e]="cannot jump from this goto statement to label %0 inside an inline assembly block",

[f]=n,

[g]="cannot jump from this goto statement to label (.*?) inside an inline assembly block",

[h]=a,

[i]=o,

[b]={"31097581aad8",1411352514,"ms-inline-asm: Scope inline asm labels to functions"},

[k]={{lb,909,"void JumpScopeChecker::CheckGotoStmt(GotoStmt *GS) {\n  if (GS->getLabel()->isMSAsmLabel()) {\n    S.Diag(GS->getGotoLoc(), diag::err_goto_ms_asm_label) << GS->getLabel()->getIdentifier();"}}

["err_half_const_requires_fp16"]={

[j]="half precision constant requires cl_khr_fp16",

[c]=l,

[d]=m,

[e]="half precision constant requires cl_khr_fp16",

[f]=n,

[g]="half precision constant requires cl_khr_fp16",

[h]=a,

[i]=o,

[b]={"5c1a2c5d3e8f",1455708877,"[OpenCL] Added half type literal with suffix h."},

[k]={{q,3512,"ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {\n  if (Literal.isFixedPointLiteral()) {\n  } else if (Literal.isFloatingLiteral()) {\n    if (Literal.isHalf) {\n      if (getOpenCLOptions().isAvailableOption(\"cl_khr_fp16\", getLangOpts()))\n      else {\n        Diag(Tok.getLocation(), diag::err_half_const_requires_fp16);"}}

["err_header_import_not_header_unit"]={

[j]="header file A (aka \'B\') cannot be imported because it is not known to be a header unit",

[c]=l,

[d]=m,

[e]="header file %0 (aka \'%1\') cannot be imported because it is not known to be a header unit",

[f]=n,

[g]="header file (.*?) \\(aka \'(.*?)\'\\) cannot be imported because it is not known to be a header unit",

[h]=a,

[i]=t,

[b]={"8af8b8611c5d",1555017503,"[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor."},

[k]={{rb,2172,"/// Handle either a #include-like directive or an import declaration that names\n/// a header file.\n///\n/// \\param HashLoc The location of the \'#\' token for an include, or\n///        SourceLocation() for an import declaration.\n/// \\param IncludeTok The include / include_next / import token.\n/// \\param FilenameTok The header-name token.\n/// \\param EndLoc The location at which any imported macros become visible.\n/// \\param LookupFrom For #include_next, the starting directory for the\n///        directory lookup.\n/// \\param LookupFromFile For #include_next, the starting file for the directory\n///        lookup.\nPreprocessor::ImportAction Preprocessor::HandleHeaderIncludeOrImport(SourceLocation HashLoc, Token &IncludeTok, Token &FilenameTok, SourceLocation EndLoc, ConstSearchDirIterator LookupFrom, const FileEntry *LookupFromFile) {\n  // If this is a C++20 pp-import declaration, diagnose if we didn\'t find any\n  // module corresponding to the named header.\n  if (IsImportDecl && !SuggestedModule) {\n    Diag(FilenameTok, diag::err_header_import_not_header_unit) << OriginalFilename << File->getName();"}}

["err_header_import_semi_in_macro"]={

[j]="semicolon terminating header import declaration cannot be produced by a macro",

[c]=l,

[d]=m,

[e]="semicolon terminating header import declaration cannot be produced by a macro",

[f]=n,

[g]="semicolon terminating header import declaration cannot be produced by a macro",

[h]=a,

[i]=t,

[b]={"8af8b8611c5d",1555017503,"[C++20] Implement context-sensitive header-name lexing and pp-import parsing in the preprocessor."},

[k]={{"clang/lib/Lex/Preprocessor.cpp",1118,"/// Lex a token following the \'import\' contextual keyword.\n///\n///    pp-import: [C++20]\n///          import header-name pp-import-suffix[opt] ;\n///          import header-name-tokens pp-import-suffix[opt] ;\n/// [ObjC]    @ import module-name ;\n/// [Clang]  import module-name ;\n///\n///    header-name-tokens:\n///          string-literal\n///          < [any sequence of preprocessing-tokens other than >] >\n///\n///    module-name:\n///          module-name-qualifier[opt] identifier\n///\n///    module-name-qualifier\n///          module-name-qualifier[opt] identifier .\n///\n/// We respond to a pp-import by importing macros from the named module.\nbool Preprocessor::LexAfterModuleImport(Token &Result) {\n  if (ImportingHeader) {\n    if (SemiLoc.isMacroID())\n      Diag(SemiLoc, diag::err_header_import_semi_in_macro);"}}

["err_hex_constant_requires"]={

[j]="hexadecimal floating ... requires ...",

[c]=l,

[d]=m,

[e]="hexadecimal floating %select{constant|literal}0 requires %select{an exponent|a significand}1",

[f]=n,

[g]="hexadecimal floating (?:constant|literal) requires (?:an exponent|a significand)",

[h]=a,

[i]=t,

[b]={"560a3579b29a",1457130726,"Update diagnostics now that hexadecimal literals look likely to be part of C++17."},

[k]={{W,1154,"/// ParseNumberStartingWithZero - This method is called when the first character\n/// of the number is found to be a zero.  This means it is either an octal\n/// number (like \'04\') or a hex number (\'0x123a\') a binary number (\'0b1010\') or\n/// a floating point number (01239.123e4).  Eat the prefix, determining the\n/// radix etc.\nvoid NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {\n  // Handle a hex number like 0x1234.\n  if ((c1 == \'x\' || c1 == \'X\') && (isHexDigit(s[1]) || s[1] == \'.\')) {\n    if (!HasSignificandDigits) {\n      Diags.Report(Lexer::AdvanceToTokenCharacter(TokLoc, s - ThisTokBegin, SM, LangOpts), diag::err_hex_constant_requires) << LangOpts.CPlusPlus << 1;"},{W,1184,"/// ParseNumberStartingWithZero - This method is called when the first character\n/// of the number is found to be a zero.  This means it is either an octal\n/// number (like \'04\') or a hex number (\'0x123a\') a binary number (\'0b1010\') or\n/// a floating point number (01239.123e4).  Eat the prefix, determining the\n/// radix etc.\nvoid NumericLiteralParser::ParseNumberStartingWithZero(SourceLocation TokLoc) {\n  // Handle a hex number like 0x1234.\n  if ((c1 == \'x\' || c1 == \'X\') && (isHexDigit(s[1]) || s[1] == \'.\')) {\n    // A binary exponent can appear with or with a \'.\'. If dotted, the\n    // binary exponent is required.\n    if (*s == \'p\' || *s == \'P\') {\n    } else if (saw_period) {\n      Diags.Report(Lexer::AdvanceToTokenCharacter(TokLoc, s - ThisTokBegin, SM, LangOpts), diag::err_hex_constant_requires) << LangOpts.CPlusPlus << 0;"}}

["err_hex_escape_no_digits"]={

[j]="\\A used with no following hex digits",

[c]=l,

[d]=m,

[e]="\\%0 used with no following hex digits",

[f]=n,

[g]="\\\\(.*?) used with no following hex digits",

[h]=a,

[i]=t,

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

[k]={{"clang/lib/Lex/Lexer.cpp",3082,"std::optional<uint32_t> Lexer::tryReadNumericUCN(const char *&StartPtr, const char *SlashLoc, Token *Result) {\n  if (Delimited && Kind == \'U\') {\n    if (Diagnose)\n      Diag(SlashLoc, diag::err_hex_escape_no_digits) << StringRef(KindLoc, 1);"},{W,181,"/// 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  case \'x\': { // Hex escape.\n    if (ThisTokBuf != ThisTokEnd && *ThisTokBuf == \'{\') {\n    } else if (ThisTokBuf == ThisTokEnd || !isHexDigit(*ThisTokBuf)) {\n      if (Diags)\n        Diag(Diags, Features, Loc, ThisTokBegin, EscapeBegin, ThisTokBuf, diag::err_hex_escape_no_digits) << \"x\";"},{W,414,"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 (UcnBegin[1] == \'u\' && in_char_string_literal && ThisTokBuf != ThisTokEnd && *ThisTokBuf == \'{\') {\n  } else if (ThisTokBuf == ThisTokEnd || !isHexDigit(*ThisTokBuf)) {\n    if (Diags)\n      Diag(Diags, Features, Loc, ThisTokBegin, UcnBegin, ThisTokBuf, diag::err_hex_escape_no_digits) << StringRef(&ThisTokBuf[-1], 1);"}}

["err_hidden_visibility_dllexport"]={

[j]="hidden visibility cannot be applied to \'dllexport\' declaration",

[c]=l,

[d]=m,

[e]="hidden visibility cannot be applied to \'dllexport\' declaration",

[f]=n,

[g]="hidden visibility cannot be applied to \'dllexport\' declaration",

[h]=a,

[i]=a,

[b]={"6f9c4851ab7c",1663023396,"[MinGW] Reject explicit hidden visibility applied to dllexport and hidden/protected applied to dllim..."},

[k]={{"clang/lib/CodeGen/CodeGenModule.cpp",1195,"void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const {\n  if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {\n    if (GV->hasDLLExportStorageClass()) {\n      if (LV.getVisibility() == HiddenVisibility)\n        getDiags().Report(D->getLocation(), diag::err_hidden_visibility_dllexport);"}}

["err_hip_invalid_args_builtin_mangled_name"]={

[j]="invalid argument: symbol must be a device-side function or global variable",

[c]=l,

[d]=m,

[e]="invalid argument: symbol must be a device-side function or global variable",

[f]=n,

[g]="invalid argument\\: symbol must be a device\\-side function or global variable",

[h]=a,

[i]=o,

[b]={"61d065e21ff3",1590001902,"Let clang atomic builtins fetch add/sub support floating point types"},

[k]={{y,2484,"#include \"clang/Basic/Builtins.def\"\n  case Builtin::BI__builtin_get_device_side_mangled_name: {\n    if (!Check(TheCall)) {\n      Diag(TheCall->getBeginLoc(), diag::err_hip_invalid_args_builtin_mangled_name);"}}

["err_hlsl_attr_invalid_ast_node"]={

[j]="attribute A only applies to B",

[c]=l,

[d]=m,

[e]="attribute %0 only applies to %1",

[f]=n,

[g]="attribute (.*?) only applies to (.*?)",

[h]=a,

[i]=a,

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

[k]={{v,6320,"static void handleHLSLSV_DispatchThreadIDAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // FIXME: support semantic on field.\n  // See https://github.com/llvm/llvm-project/issues/57889.\n  if (isa<FieldDecl>(D)) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_attr_invalid_ast_node) << AL << \"parameter\";"}}

["err_hlsl_attr_invalid_type"]={

[j]="attribute A only applies to a field or parameter of type \'B\'",

[c]=l,

[d]=m,

[e]="attribute %0 only applies to a field or parameter of type \'%1\'",

[f]=n,

[g]="attribute (.*?) only applies to a field or parameter of type \'(.*?)\'",

[h]=a,

[i]=a,

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

[k]={{v,6326,"static void handleHLSLSV_DispatchThreadIDAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (!isLegalTypeForHLSLSV_DispatchThreadID(VD->getType())) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_attr_invalid_type) << AL << \"uint/uint2/uint3\";"}}

["err_hlsl_attr_unsupported_in_stage"]={

[j]="attribute A is unsupported in ... shaders, requires B",

[c]=l,

[d]=m,

[e]="attribute %0 is unsupported in %select{Pixel|Vertex|Geometry|Hull|Domain|Compute|Library|RayGeneration|Intersection|AnyHit|ClosestHit|Miss|Callable|Mesh|Amplification|Invalid}1 shaders, requires %2",

[f]=n,

[g]="attribute (.*?) is unsupported in (?:Pixel|Vertex|Geometry|Hull|Domain|Compute|Library|RayGeneration|Intersection|AnyHit|ClosestHit|Miss|Callable|Mesh|Amplification|Invalid) shaders, requires (.*?)",

[h]=a,

[i]=a,

[b]={Cb,1620118562,Eb},

[k]={{v,6223,"static void handleHLSLNumThreadsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (!llvm::is_contained({Triple::Compute, Triple::Mesh, Triple::Amplification, Triple::Library}, Env)) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_attr_unsupported_in_stage) << AL << Pipeline << \"Compute, Amplification, Mesh or Library\";"},{v,6288,"static void handleHLSLSVGroupIndexAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (Env != Triple::Compute && Env != Triple::Library) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_attr_unsupported_in_stage) << AL << (uint32_t)Pipeline << \"Compute\";"},{v,6310,"static void handleHLSLSV_DispatchThreadIDAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // FIXME: it is OK for a compute shader entry and pixel shader entry live in\n  // same HLSL file.Issue https://github.com/llvm/llvm-project/issues/57880.\n  if (Target.getEnvironment() != Triple::Compute && Target.getEnvironment() != Triple::Library) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_attr_unsupported_in_stage) << AL << Pipeline << \"Compute\";"}}

["err_hlsl_attribute_param_mismatch"]={

[j]="A attribute parameters do not match the previous declaration",

[c]=l,

[d]=m,

[e]="%0 attribute parameters do not match the previous declaration",

[f]=n,

[g]="(.*?) attribute parameters do not match the previous declaration",

[h]=a,

[i]=a,

[b]={Cb,1620118562,Eb},

[k]={{v,6273,"HLSLNumThreadsAttr *Sema::mergeHLSLNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z) {\n  if (HLSLNumThreadsAttr *NT = D->getAttr<HLSLNumThreadsAttr>()) {\n    if (NT->getX() != X || NT->getY() != Y || NT->getZ() != Z) {\n      Diag(NT->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;"},{v,6359,"HLSLShaderAttr *Sema::mergeHLSLShaderAttr(Decl *D, const AttributeCommonInfo &AL, HLSLShaderAttr::ShaderType ShaderType) {\n  if (HLSLShaderAttr *NT = D->getAttr<HLSLShaderAttr>()) {\n    if (NT->getType() != ShaderType) {\n      Diag(NT->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;"}}

["err_hlsl_entry_shader_attr_mismatch"]={

[j]="A attribute on entry function does not match the pipeline stage",

[c]=l,

[d]=m,

[e]="%0 attribute on entry function does not match the pipeline stage",

[f]=n,

[g]="(.*?) attribute on entry function does not match the pipeline stage",

[h]=a,

[i]=a,

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

[k]={{p,8997,"NamedDecl *Sema::ActOnFunctionDeclarator(Scope *S, Declarator &D, DeclContext *DC, TypeSourceInfo *TInfo, LookupResult &Previous, MultiTemplateParamsArg TemplateParamListsRef, bool &AddToScope) {\n  if (getLangOpts().HLSL) {\n    // Skip operator overload which not identifier.\n    // Also make sure NewFD is in translation-unit scope.\n    if (!NewFD->isInvalidDecl() && Name.isIdentifier() && NewFD->getName() == TargetInfo.getTargetOpts().HLSLEntry && S->getDepth() == 0) {\n      if (!NewFD->isInvalidDecl()) {\n        // To share code with HLSLShaderAttr, add HLSLShaderAttr to entry\n        // function.\n        if (HLSLShaderAttr *NT = NewFD->getAttr<HLSLShaderAttr>()) {\n          if (NT->getType() != ShaderType)\n            Diag(NT->getLocation(), diag::err_hlsl_entry_shader_attr_mismatch) << NT;"}}

["err_hlsl_expected_space"]={

[j]="invalid space specifier \'A\' used; expected \'space\' followed by an integer, like space1",

[c]=l,

[d]=m,

[e]="invalid space specifier \'%0\' used; expected \'space\' followed by an integer, like space1",

[f]=n,

[g]="invalid space specifier \'(.*?)\' used; expected \'space\' followed by an integer, like space1",

[h]=a,

[i]=a,

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

[k]={{v,6417,"static void handleHLSLResourceBindingAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (!Space.startswith(\"space\")) {\n    S.Diag(SpaceArgLoc, diag::err_hlsl_expected_space) << Space;"},{v,6423,"static void handleHLSLResourceBindingAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (SpaceNum.getAsInteger(10, Num)) {\n    S.Diag(SpaceArgLoc, diag::err_hlsl_expected_space) << Space;"}}

["err_hlsl_init_priority_unsupported"]={

[j]="initializer priorities are not supported in HLSL",

[c]=l,

[d]=m,

[e]="initializer priorities are not supported in HLSL",

[f]=n,

[g]="initializer priorities are not supported in HLSL",

[h]=a,

[i]=a,

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

[k]={{v,2105,"static void handleConstructorAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.getLangOpts().HLSL && AL.getNumArgs()) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_init_priority_unsupported);"},{v,3365,"/// Handle __attribute__((init_priority(priority))) attributes based on\n/// http://gcc.gnu.org/onlinedocs/gcc/C_002b_002b-Attributes.html\nstatic void handleInitPriorityAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (S.getLangOpts().HLSL) {\n    S.Diag(AL.getLoc(), diag::err_hlsl_init_priority_unsupported);"}}

["err_hlsl_missing_numthreads"]={

[j]="missing numthreads attribute for A shader entry",

[c]=l,

[d]=m,

[e]="missing numthreads attribute for %0 shader entry",

[f]=n,

[g]="missing numthreads attribute for (.*?) shader entry",

[h]=a,

[i]=a,

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

[k]={{p,10729,"void Sema::CheckHLSLEntryPoint(FunctionDecl *FD) {\n  case llvm::Triple::EnvironmentType::Compute:\n    if (!FD->hasAttr<HLSLNumThreadsAttr>()) {\n      Diag(FD->getLocation(), diag::err_hlsl_missing_numthreads) << Triple.getEnvironmentName();"}}

["err_hlsl_missing_semantic_annotation"]={

[j]="semantic annotations must be present for all parameters of an entry function or patch constant function",

[c]=l,

[d]=m,

[e]="semantic annotations must be present for all parameters of an entry function or patch constant function",

[f]=n,

[g]="semantic annotations must be present for all parameters of an entry function or patch constant function",

[h]=a,

[i]=a,

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

[k]={{p,10739,"void Sema::CheckHLSLEntryPoint(FunctionDecl *FD) {\n  for (const auto *Param : FD->parameters()) {\n    if (!Param->hasAttr<HLSLAnnotationAttr>()) {\n      Diag(FD->getLocation(), diag::err_hlsl_missing_semantic_annotation);"}}

["err_hlsl_numthreads_argument_oor"]={

[j]="argument \'...\' to numthreads attribute cannot exceed A",

[c]=l,

[d]=m,

[e]="argument \'%select{X|Y|Z}0\' to numthreads attribute cannot exceed %1",

[f]=n,

[g]="argument \'(?:X|Y|Z)\' to numthreads attribute cannot exceed (.*?)",

[h]=a,

[i]=a,

[b]={Cb,1620118562,Eb},

[k]={{v,6242,"static void handleHLSLNumThreadsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (X > 1024) {\n    S.Diag(AL.getArgAsExpr(0)->getExprLoc(), diag::err_hlsl_numthreads_argument_oor) << 0 << 1024;"},{v,6249,"static void handleHLSLNumThreadsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (Y > 1024) {\n    S.Diag(AL.getArgAsExpr(1)->getExprLoc(), diag::err_hlsl_numthreads_argument_oor) << 1 << 1024;"},{v,6256,"static void handleHLSLNumThreadsAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (Z > ZMax) {\n    S.Diag(AL.getArgAsExpr(2)->getExprLoc(), diag::err_hlsl_numthreads_argument_oor) << 2 << ZMax;"}}