Module:ClangDiags/DiagsLongData6: Difference between revisions

local b="id_hist";

local c="regex2";

local d="source";

local e="category_hist";

local f="regex3";

local g="commit";

local h="regex1";

local i="hierarchical_hist";

local j="message_hist";

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

local r="The basic representation of diagnostics information in tablegen format, plus (uncommented and incomplete) test conversions of the existing def files to this format.\n\nllvm-svn: 66064";

local s="b1c4d5507fad";

local L="5a8987ca5113";

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

local S="Add #pragma clang attribute\n\nThe new \'#pragma clang attribute\' directive can be used to apply attributes to\nmultiple declarations. An attribute must satisfy the following conditions to\nbe supported by the pragma:\n- It must have a subject list that\'s defined in the TableGen file.\n- It must be documented.\n- It must not be late parsed.\n- It must have a GNU/C++11 spelling.\n\nDifferential Revision: https://reviews.llvm.org/D30009\n\nllvm-svn: 300539";

local T="Add #pragma clang attribute";

local U="13.0";

local V="AST Deserialization Issue";

local X="clang/test/Parser/pragma-attribute.cpp";

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

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

local bb="f881267db9a9";

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

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

local gb="739b410f1ff5";

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

local ib="95f50964fbf5";

local kb="Implement P2361 Unevaluated string literals";

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

local mb="16.0";

local nb="[WebAssembly] Improve clang diagnostics for wasm attributes\n\nThis patch addresses the review comments on r352930:\n\n - Removes redundant diagnostic checking code\n - Removes errnoneous use of diag::err_alias_is_definition, which\n  turned out to be ineffective anyway since functions can be defined later\n  in the translation unit and avoid detection.\n - Adds a test for various invalid cases for import_name and import_module.\n\nDifferential Revision: https://reviews.llvm.org/D59520";

local ob="invalid";

local pb="clang/lib/Basic/Targets/PPC.cpp";

local qb="931fcd3ba011";

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

local tb="clang/lib/Sema/SemaTemplateVariadic.cpp";

local ub="clang/test/SemaCXX/overloaded-operator-decl.cpp";

local vb=" B";

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

local xb="static_cast";

local yb="Add #pragma clang module begin/end pragmas and generate them when preprocessing a module.\n\nThese pragmas are intended to simulate the effect of entering or leaving a file\nwith an associated module. This is not completely implemented yet: declarations\nbetween the pragmas will not be attributed to the correct module, but macro\nvisibility is already functional.\n\nModules named by #pragma clang module begin must already be known to clang (in\nsome module map that\'s either loaded or on the search path).\n\nllvm-svn: 302098";

local zb="missing";

local Cb="expected \'begin\' or \'end\'";

local Db="[clang] Implement objc_non_runtime_protocol to remove protocol metadata\n\nSummary:\nMotivated by the new objc_direct attribute, this change adds a new\nattribute that remotes metadata from Protocols that the programmer knows\nisn\'t going to be used at runtime. We simply have the frontend skip\ngenerating any protocol metadata entries (e.g. OBJC_CLASS_NAME,\n_OBJC_$_PROTOCOL_INSTANCE_METHDOS, _OBJC_PROTOCOL, etc) for a protocol\nmarked with `__attribute__((objc_non_runtime_protocol))`.\n\nThere are a few APIs used to retrieve a protocol at runtime.\n`@protocol(SomeProtocol)` will now error out of the requested protocol\nis marked with attribute. `objc_getProtocol` will return `NULL` which\nis consistent with the behavior of a non-existing protocol.\n\nSubscribers: cfe-commits\n\nTags: #clang\n\nDifferential Revision: https://reviews.llvm.org/D75574";

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

local Fb="Refactoring Invocation Issue";

local Gb="11.1";

local Hb="clang/lib/Lex/PPLexerChange.cpp";

local Ib="d13863008b38";

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

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

local Lb=" option";

local Mb="C-style cast";

local Nb="reinterpret_cast";

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

local Pb="clang/test/Parser/cxx2a-concepts-requires-expr.cpp";

local Qb="dynamic_cast";

local Sb="functional-style cast";

local Tb="61d065e21ff3";

local Vb="Let clang atomic builtins fetch add/sub support floating point types\n\nRecently atomicrmw started to support fadd/fsub:\n\nhttps://reviews.llvm.org/D53965\n\nHowever clang atomic builtins fetch add/sub still does not support\nemitting atomicrmw fadd/fsub.\n\nThis patch adds that.\n\nReviewed by: John McCall, Artem Belevich, Matt Arsenault, JF Bastien,\nJames Y Knight, Louis Dionne, Olivier Giroux\n\nDifferential Revision: https://reviews.llvm.org/D71726";

local Zb="unavailable";

local ac="deleted";

local ec="clang/test/Preprocessor/line-directive.c";

local fc="Modules Issue";

local gc="__global__";

local ic="__host__ __device__";

local jc="__device__";

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

local lc="Nullability Issue";

local mc="fatal error\\: ";

local nc="Improve diagnostics for malformed delete operator function declarations.\n\nllvm-svn: 91180";

local oc="Improve diagnostics for malformed delete operator function declarations.";

local sc="Introduced pragmas for audited nullability regions.";

local tc="clang/test/Sema/pragma-arc-cf-code-audited.c";

local uc="Introduced pragmas for audited nullability regions.\n\nIntroduce the clang pragmas \"assume_nonnull begin\" and \"assume_nonnull\nend\" in which we make default assumptions about the nullability of many\nunannotated pointers:\n\n  - Single-level pointers are inferred to __nonnull\n  - NSError** in a (function or method) parameter list is inferred to\n    NSError * __nullable * __nullable.\n  - CFErrorRef * in a (function or method) parameter list is inferred\n    to CFErrorRef __nullable * __nullable.\n  - Other multi-level pointers are never inferred to anything.\n\nImplements rdar://problem/19191042.\n\nllvm-svn: 240156";

[b]="err_operator_arrow_circular",

[j]="circular pointer delegation detected",

[i]="circular pointer delegation detected",

[h]=k,

[c]="circular pointer delegation detected",

[f]=a,

[e]=m,

[g]={"10ce958550c7",1254269981,"self-referecing operator \'->\' member function was causing","self-referecing operator \'->\' member function was causing\ninfinit recursion. This patch fixes it. [13.3.1.2]-p2\n\nllvm-svn: 83124"},

[d]={{Q,7630,"ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor) {\n  // ...\n  // C++ [over.match.oper]p8:\n  //  [...] When operator->returns, the operator-> is applied  to the value\n  //  returned, with the original second operand.\n  if (OpKind == tok::arrow) {\n    // ...\n    while (BaseType->isRecordType()) {\n      // ...\n      if (!CTypes.insert(CBaseType).second) {\n        Diag(OpLoc, diag::err_operator_arrow_circular) << StartingType;"}},

[b]="err_operator_arrow_depth_exceeded",

[j]="use of \'operator->\' on type %0 would invoke a sequence of more than %1 \'operator->\' calls",

[i]="use of \'operator->\' on type A would invoke a sequence of more than B \'operator->\' calls",

[h]=k,

[c]="use of \'operator\\-\\>\' on type (.*?) would invoke a sequence of more than (.*?) \'operator\\-\\>\' calls",

[f]=a,

[e]=m,

[g]={"79c927bfe9fc",1383766311,"Add a limit to the length of a sequence of \'operator->\' functions we will","Add a limit to the length of a sequence of \'operator->\' functions we will\nfollow when building a class member access expression. Based on a patch by\nRahul Jain!\n\nllvm-svn: 194161"},

[d]={{Q,7588,"ExprResult Sema::ActOnStartCXXMemberReference(Scope *S, Expr *Base, SourceLocation OpLoc, tok::TokenKind OpKind, ParsedType &ObjectType, bool &MayBePseudoDestructor) {\n  // ...\n  // C++ [over.match.oper]p8:\n  //  [...] When operator->returns, the operator-> is applied  to the value\n  //  returned, with the original second operand.\n  if (OpKind == tok::arrow) {\n    // ...\n    while (BaseType->isRecordType()) {\n      if (OperatorArrows.size() >= getLangOpts().ArrowDepth) {\n        Diag(OpLoc, diag::err_operator_arrow_depth_exceeded) << StartingType << getLangOpts().ArrowDepth << Base->getSourceRange();"}},

[b]="err_operator_delete_dependent_param_type",

[j]="%0 cannot take a dependent type as first parameter; use %1 instead",

[i]="A cannot take a dependent type as first parameter; use B instead",

[h]=k,

[c]="(.*?) cannot take a dependent type as first parameter; use (.*?) instead",

[f]=a,

[e]=m,

[g]={"c0b2ce14cdc1",1260576962,"More work on improving the operator delete diagnostics.","More work on improving the operator delete diagnostics.\n\nllvm-svn: 91187"},

[d]={{w,16101,"static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {\n  // ...\n  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType, diag::err_operator_delete_dependent_param_type, diag::err_operator_delete_param_type))"}},

[b]="err_operator_delete_param_type",

[j]="first parameter of %0 must have type %1",

[i]="first parameter of A must have type B",

[h]=k,

[c]="first parameter of (.*?) must have type (.*?)",

[f]=a,

[e]=m,

[g]={pc,1260573802,oc,nc},

[d]={{w,16102,"static bool CheckOperatorDeleteDeclaration(Sema &SemaRef, FunctionDecl *FnDecl) {\n  // ...\n  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidTy, ExpectedFirstParamType, diag::err_operator_delete_dependent_param_type, diag::err_operator_delete_param_type))"}},

[b]="err_operator_new_default_arg",

[j]="parameter of %0 cannot have a default argument",

[i]="parameter of A cannot have a default argument",

[h]=k,

[c]="parameter of (.*?) cannot have a default argument",

[f]=a,

[e]=m,

[g]={"7e0b207e5478",1260726823,"More improvements to checking allocation and deallocation functions.","More improvements to checking allocation and deallocation functions.\n\nllvm-svn: 91244"},

[d]={{w,16070,"static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {\n  // ...\n  // C++ [basic.stc.dynamic.allocation]p1:\n  //  The first parameter shall not have an associated default argument.\n  if (FnDecl->getParamDecl(0)->hasDefaultArg())\n    return SemaRef.Diag(FnDecl->getLocation(), diag::err_operator_new_default_arg) << FnDecl->getDeclName() << FnDecl->getParamDecl(0)->getDefaultArgRange();"}},

[b]="err_operator_new_delete_declared_in_namespace",

[j]="%0 cannot be declared inside a namespace",

[i]="A cannot be declared inside a namespace",

[h]=k,

[c]="(.*?) cannot be declared inside a namespace",

[f]=a,

[e]=m,

[g]={pc,1260573802,oc,nc},

[d]={{w,15951,"static inline bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl) {\n  // ...\n  if (isa<NamespaceDecl>(DC)) {\n    return SemaRef.Diag(FnDecl->getLocation(), diag::err_operator_new_delete_declared_in_namespace) << FnDecl->getDeclName();"}},

[b]="err_operator_new_delete_declared_static",

[j]="%0 cannot be declared static in global scope",

[i]="A cannot be declared static in global scope",

[h]=k,

[c]="(.*?) cannot be declared static in global scope",

[f]=a,

[e]=m,

[g]={pc,1260573802,oc,nc},

[d]={{w,15958,"static inline bool CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef, const FunctionDecl *FnDecl) {\n  // ...\n  if (isa<TranslationUnitDecl>(DC) && FnDecl->getStorageClass() == SC_Static) {\n    return SemaRef.Diag(FnDecl->getLocation(), diag::err_operator_new_delete_declared_static) << FnDecl->getDeclName();"}},

[b]="err_operator_new_delete_dependent_result_type",

[j]="%0 cannot have a dependent return type; use %1 instead",

[i]="A cannot have a dependent return type; use B instead",

[h]=k,

[c]="(.*?) cannot have a dependent return type; use (.*?) instead",

[f]=a,

[e]=m,

[g]={"c0b2ce14cdc1",1260576962,"More work on improving the operator delete diagnostics.","More work on improving the operator delete diagnostics.\n\nllvm-svn: 91187"},

[d]={{w,16000,"static inline bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag) {\n  // ...\n  // Check that the result type is what we expect.\n  if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType) {\n    // ...\n    return SemaRef.Diag(FnDecl->getLocation(), ResultType->isDependentType() ? diag::err_operator_new_delete_dependent_result_type : diag::err_operator_new_delete_invalid_result_type) << FnDecl->getDeclName() << ExpectedResultType;"}},

[b]="err_operator_new_delete_invalid_result_type",

[j]="%0 must return type %1",

[i]="A must return type B",

[h]=k,

[c]="(.*?) must return type (.*?)",

[f]=a,

[e]=m,

[g]={pc,1260573802,oc,nc},

[d]={{w,16001,"static inline bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag) {\n  // ...\n  // Check that the result type is what we expect.\n  if (SemaRef.Context.getCanonicalType(ResultType) != ExpectedResultType) {\n    // ...\n    return SemaRef.Diag(FnDecl->getLocation(), ResultType->isDependentType() ? diag::err_operator_new_delete_dependent_result_type : diag::err_operator_new_delete_invalid_result_type) << FnDecl->getDeclName() << ExpectedResultType;"}},

[b]="err_operator_new_delete_template_too_few_parameters",

[j]="%0 template must have at least two parameters",

[i]="A template must have at least two parameters",

[h]=k,

[c]="(.*?) template must have at least two parameters",

[f]=a,

[e]=m,

[g]={"c0b2ce14cdc1",1260576962,"More work on improving the operator delete diagnostics.","More work on improving the operator delete diagnostics.\n\nllvm-svn: 91187"},

[d]={{w,16008,"static inline bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag) {\n  // ...\n  // A function template must have at least 2 parameters.\n  if (FnDecl->getDescribedFunctionTemplate() && FnDecl->getNumParams() < 2)\n    return SemaRef.Diag(FnDecl->getLocation(), diag::err_operator_new_delete_template_too_few_parameters) << FnDecl->getDeclName();"}},

[b]="err_operator_new_delete_too_few_parameters",

[j]="%0 must have at least one parameter",

[i]="A must have at least one parameter",

[h]=k,

[c]="(.*?) must have at least one parameter",

[f]=a,

[e]=m,

[g]={pc,1260573802,oc,nc},

[d]={{w,16014,"static inline bool CheckOperatorNewDeleteTypes(Sema &SemaRef, const FunctionDecl *FnDecl, CanQualType ExpectedResultType, CanQualType ExpectedFirstParamType, unsigned DependentParamTypeDiag, unsigned InvalidParamTypeDiag) {\n  // ...\n  // The function decl must have at least 1 parameter.\n  if (FnDecl->getNumParams() == 0)\n    return SemaRef.Diag(FnDecl->getLocation(), diag::err_operator_new_delete_too_few_parameters) << FnDecl->getDeclName();"}},

[b]="err_operator_new_dependent_param_type",

[j]="%0 cannot take a dependent type as first parameter; use size_t (%1) instead",

[i]="A cannot take a dependent type as first parameter; use size_t (B) instead",

[h]=k,

[c]="(.*?) cannot take a dependent type as first parameter; use size_t \\((.*?)\\) instead",

[f]=a,

[e]=m,

[g]={"c0b2ce14cdc1",1260576962,"More work on improving the operator delete diagnostics.","More work on improving the operator delete diagnostics.\n\nllvm-svn: 91187"},

[d]={{w,16062,"static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {\n  // ...\n  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy, SizeTy, diag::err_operator_new_dependent_param_type, diag::err_operator_new_param_type))"}},

[b]="err_operator_new_param_type",

[j]="%0 takes type size_t (%1) as first parameter",

[i]="A takes type size_t (B) as first parameter",

[h]=k,

[c]="(.*?) takes type size_t \\((.*?)\\) as first parameter",

[f]=a,

[e]=m,

[g]={"4e088941ad99",1257896838,"Diagnose illegally typed operator new/new[].","Diagnose illegally typed operator new/new[].\n\nllvm-svn: 86755"},

[d]={{w,16063,"static bool CheckOperatorNewDeclaration(Sema &SemaRef, const FunctionDecl *FnDecl) {\n  // ...\n  if (CheckOperatorNewDeleteTypes(SemaRef, FnDecl, SemaRef.Context.VoidPtrTy, SizeTy, diag::err_operator_new_dependent_param_type, diag::err_operator_new_param_type))"}},

[b]="err_operator_overload_default_arg",

[j]="parameter of overloaded %0 cannot have a default argument",

[i]="parameter of overloaded A cannot have a default argument",

[h]=k,

[c]="parameter of overloaded (.*?) cannot have a default argument",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16198,"/// CheckOverloadedOperatorDeclaration - Check whether the declaration\n/// of this overloaded operator is well-formed. If so, returns false;\n/// otherwise, emits appropriate diagnostics and returns true.\nbool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {\n  // ...\n  // C++ [over.oper]p8:\n  //  An operator function cannot have default arguments (8.3.6),\n  //  except where explicitly stated below.\n  //\n  // Only the function-call operator (C++ [over.call]p1) and the subscript\n  // operator (CWG2507) allow default arguments.\n  if (Op != OO_Call) {\n    // ...\n    if (FirstDefaultedParam) {\n      if (Op == OO_Subscript) {\n      // ...\n      } else {\n        return Diag(FirstDefaultedParam->getLocation(), diag::err_operator_overload_default_arg) << FnDecl->getDeclName() << FirstDefaultedParam->getDefaultArgRange();"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:25:18: error: parameter of overloaded \'operator*\' cannot have a default argument"}

[b]="err_operator_overload_must_be",

[j]="overloaded %0 must be a %select{unary|binary|unary or binary}2 operator (has %1 parameter%s1)",

[i]={{nil,nil,{"overloaded A must be a ",{"unary","binary","unary or binary"}," operator (has B parameterB)"}}},

[h]=k,

[c]="overloaded (.*?) must be a (?:unary|binary|unary or binary) operator \\(has (.*?) parameter(.*?)\\)",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16237,"#include \"clang/Basic/OperatorKinds.def\"\n  // ...\n  if (Op != OO_Call && Op != OO_Subscript && ((NumParams == 1 && !CanBeUnaryOperator) || (NumParams == 2 && !CanBeBinaryOperator) || (NumParams < 1) || (NumParams > 2))) {\n    // ...\n    return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be) << FnDecl->getDeclName() << NumParams << ErrorKind;"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:29:3: error: overloaded \'operator%\' must be a binary operator (has 1 parameter)"}

[b]="err_operator_overload_must_be_member",

[j]="overloaded %0 must be a non-static member function",

[i]="overloaded A must be a non-static member function",

[h]=k,

[c]="overloaded (.*?) must be a non\\-static member function",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16259,"#include \"clang/Basic/OperatorKinds.def\"\n  // ...\n  // Some operators must be member functions.\n  if (MustBeMemberOperator && !isa<CXXMethodDecl>(FnDecl)) {\n    return Diag(FnDecl->getLocation(), diag::err_operator_overload_must_be_member) << FnDecl->getDeclName();"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:31:6: error: overloaded \'operator()\' must be a non-static member function"}

[b]="err_operator_overload_needs_class_or_enum",

[j]="overloaded %0 must have at least one parameter of class or enumeration type",

[i]="overloaded A must have at least one parameter of class or enumeration type",

[h]=k,

[c]="overloaded (.*?) must have at least one parameter of class or enumeration type",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16171,"/// CheckOverloadedOperatorDeclaration - Check whether the declaration\n/// of this overloaded operator is well-formed. If so, returns false;\n/// otherwise, emits appropriate diagnostics and returns true.\nbool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {\n  // ...\n  // C++ [over.oper]p7:\n  //  An operator function shall either be a member function or\n  //  be a non-member function and have at least one parameter\n  //  whose type is a class, a reference to a class, an enumeration,\n  //  or a reference to an enumeration.\n  // Note: Before C++23, a member function could not be static. The only member\n  //      function allowed to be static is the call operator function.\n  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {\n  // ...\n  } else {\n    // ...\n    if (!ClassOrEnumParam)\n      return Diag(FnDecl->getLocation(), diag::err_operator_overload_needs_class_or_enum) << FnDecl->getDeclName();"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:23:3: error: overloaded \'operator+\' must have at least one parameter of class or enumeration type"}

[b]="err_operator_overload_post_incdec_must_be_int",

[j]="parameter of overloaded post-%select{increment|decrement}1 operator must have type \'int\' (not %0)",

[i]={{nil,nil,{"parameter of overloaded post-",{"increment","decrement"}," operator must have type \'int\' (not A)"}}},

[h]=k,

[c]="parameter of overloaded post\\-(?:increment|decrement) operator must have type \'int\' \\(not (.*?)\\)",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16280,"#include \"clang/Basic/OperatorKinds.def\"\n  // ...\n  // C++ [over.inc]p1:\n  //  The user-defined function called operator++ implements the\n  //  prefix and postfix ++ operator. If this function is a member\n  //  function with no parameters, or a non-member function with one\n  //  parameter of class or enumeration type, it defines the prefix\n  //  increment operator ++ for objects of that type. If the function\n  //  is a member function with one parameter (which shall be of type\n  //  int) or a non-member function with two parameters (the second\n  //  of which shall be of type int), it defines the postfix\n  //  increment operator ++ for objects of that type.\n  if ((Op == OO_PlusPlus || Op == OO_MinusMinus) && NumParams == 2) {\n    // ...\n    if (!ParamType->isSpecificBuiltinType(BuiltinType::Int) && !ParamType->isDependentType())\n      return Diag(LastParam->getLocation(), diag::err_operator_overload_post_incdec_must_be_int) << LastParam->getType() << (Op == OO_MinusMinus);"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:37:23: error: parameter of overloaded post-increment operator must have type \'int\' (not \'FLOAT\' (aka \'float\'))"}

[b]="err_operator_overload_static",

[j]="overloaded %0 cannot be a static member function",

[i]="overloaded A cannot be a static member function",

[h]=k,

[c]="overloaded (.*?) cannot be a static member function",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16155,"/// CheckOverloadedOperatorDeclaration - Check whether the declaration\n/// of this overloaded operator is well-formed. If so, returns false;\n/// otherwise, emits appropriate diagnostics and returns true.\nbool Sema::CheckOverloadedOperatorDeclaration(FunctionDecl *FnDecl) {\n  // ...\n  // C++ [over.oper]p7:\n  //  An operator function shall either be a member function or\n  //  be a non-member function and have at least one parameter\n  //  whose type is a class, a reference to a class, an enumeration,\n  //  or a reference to an enumeration.\n  // Note: Before C++23, a member function could not be static. The only member\n  //      function allowed to be static is the call operator function.\n  if (CXXMethodDecl *MethodDecl = dyn_cast<CXXMethodDecl>(FnDecl)) {\n    if (MethodDecl->isStatic()) {\n      if (Op == OO_Call || Op == OO_Subscript)\n      // ...\n      else\n        return Diag(FnDecl->getLocation(), diag::err_operator_overload_static) << FnDecl;"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:15:14: error: overloaded \'operator+\' cannot be a static member function"}

[b]="err_operator_overload_variadic",

[j]="overloaded %0 cannot be variadic",

[i]="overloaded A cannot be variadic",

[h]=k,

[c]="overloaded (.*?) cannot be variadic",

[f]=a,

[e]=m,

[g]={L,1237025389,M,N},

[d]={{w,16252,"#include \"clang/Basic/OperatorKinds.def\"\n  // ...\n  // Overloaded operators other than operator() and operator[] cannot be\n  // variadic.\n  if (Op != OO_Call && FnDecl->getType()->castAs<FunctionProtoType>()->isVariadic()) {\n    return Diag(FnDecl->getLocation(), diag::err_operator_overload_variadic) << FnDecl->getDeclName();"}},

[ub]={"clang/test/SemaCXX/overloaded-operator-decl.cpp:27:3: error: overloaded \'operator/\' cannot be variadic"}

[b]={{nil,K,"err_opt_not_valid_on_target"}},

[j]={{nil,K,"option \'%0\' cannot be specified on this target"}},

[i]={{nil,K,"option \'A\' cannot be specified on this target"}},

[h]=k,

[c]="option \'(.*?)\' cannot be specified on this target",

[f]=a,

[e]={{nil,K,a}},

[g]={"0fb8c877c4a3",1526644581,"This patch aims to match the changes introduced","This patch aims to match the changes introduced\nin gcc by https://gcc.gnu.org/ml/gcc-cvs/2018-04/msg00534.html.\nThe -mibt feature flag is being removed, and the -fcf-protection\noption now also defines a CET macro and causes errors when used\non non-X86 targets, while X86 targets no longer check for -mibt\nand -mshstk to determine if -fcf-protection is supported. -mshstk\nis now used only to determine availability of shadow stack intrinsics.\n\nComes with an LLVM patch (D46882).\n\nPatch by mike.dvoretsky\n\nDifferential Revision: https://reviews.llvm.org/D46881\n\nllvm-svn: 332704"},

[d]={{"clang/lib/Basic/TargetInfo.cpp",197,"bool TargetInfo::checkCFProtectionBranchSupported(DiagnosticsEngine &Diags) const {\n  Diags.Report(diag::err_opt_not_valid_on_target) << \"cf-protection=branch\";"},{"clang/lib/Basic/TargetInfo.cpp",203,"bool TargetInfo::checkCFProtectionReturnSupported(DiagnosticsEngine &Diags) const {\n  Diags.Report(diag::err_opt_not_valid_on_target) << \"cf-protection=return\";"},{"clang/lib/Basic/TargetInfo.cpp",511,"/// adjust - Set forced language options.\n/// Apply changes to the target information with respect to certain\n/// language options which change the target configuration and adjust\n/// the language based on the target options where applicable.\nvoid TargetInfo::adjust(DiagnosticsEngine &Diags, LangOptions &Opts) {\n  // ...\n  if (Opts.ProtectParens && !checkArithmeticFenceSupported()) {\n    Diags.Report(diag::err_opt_not_valid_on_target) << \"-fprotect-parens\";"},{"clang/lib/CodeGen/CodeGenFunction.cpp",1098,"#include \"clang/Basic/Sanitizers.def\"\n  // ...\n  if (CGM.getCodeGenOpts().PackedStack) {\n    if (getContext().getTargetInfo().getTriple().getArch() != llvm::Triple::systemz)\n      CGM.getDiags().Report(diag::err_opt_not_valid_on_target) << \"-mpacked-stack\";"}}

[b]="err_opt_not_valid_with_opt",

[j]="option \'%0\' cannot be specified with \'%1\'",

[i]="option \'A\' cannot be specified with \'B\'",

[h]=k,

[c]="option \'(.*?)\' cannot be specified with \'(.*?)\'",

[f]=a,

[e]=a,

[g]={"26c3534b84f2",1436533894,"Add missing builtins to altivec.h for ABI compliance (vol. 3)","Add missing builtins to altivec.h for ABI compliance (vol. 3)\n\nThis patch corresponds to review:\nhttp://reviews.llvm.org/D10972\n\nFix for the handling of dependent features that are enabled by default\non some CPU\'s (such as -mvsx, -mpower8-vector).\n\nAlso provides a number of new interfaces or fixes existing ones in\naltivec.h.\n\nChanged signatures to conform to ABI:\nvector short vec_perm(vector signed short, vector signed short, vector unsigned char)\nvector int vec_perm(vector signed int, vector signed int, vector unsigned char)\nvector long long vec_perm(vector signed long long, vector signed long long, vector unsigned char)\nvector signed char vec_sld(vector signed char, vector signed char, const int)\nvector unsigned char vec_sld(vector unsigned char, vector unsigned char, const int)\nvector bool char vec_sld(vector bool char, vector bool char, const int)\nvector unsigned short vec_sld(vector unsigned short, vector unsigned short, const int)\nvector signed short vec_sld(vector signed short, vector signed short, const int)\nvector signed int vec_sld(vector signed int, vector signed int, const int)\nvector unsigned int vec_sld(vector unsigned int, vector unsigned int, const int)\nvector float vec_sld(vector float, vector float, const int)\nvector signed char vec_splat(vector signed char, const int)\nvector unsigned char vec_splat(vector unsigned char, const int)\nvector bool char vec_splat(vector bool char, const int)\nvector signed short vec_splat(vector signed short, const int)\nvector unsigned short vec_splat(vector unsigned short, const int)\nvector bool short vec_splat(vector bool short, const int)\nvector pixel vec_splat(vector pixel, const int)\nvector signed int vec_splat(vector signed int, const int)\nvector unsigned int vec_splat(vector unsigned int, const int)\nvector bool int vec_splat(vector bool int, const int)\nvector float vec_splat(vector float, const int)\n\nAdded a VSX path to:\nvector float vec_round(vector float)\n\nAdded interfaces:\nvector signed char vec_eqv(vector signed char, vector signed char)\nvector signed char vec_eqv(vector bool char, vector signed char)\nvector signed char vec_eqv(vector signed char, vector bool char)\nvector unsigned char vec_eqv(vector unsigned char, vector unsigned char)\nvector unsigned char vec_eqv(vector bool char, vector unsigned char)\nvector unsigned char vec_eqv(vector unsigned char, vector bool char)\nvector signed short vec_eqv(vector signed short, vector signed short)\nvector signed short vec_eqv(vector bool short, vector signed short)\nvector signed short vec_eqv(vector signed short, vector bool short)\nvector unsigned short vec_eqv(vector unsigned short, vector unsigned short)\nvector unsigned short vec_eqv(vector bool short, vector unsigned short)\nvector unsigned short vec_eqv(vector unsigned short, vector bool short)\nvector signed int vec_eqv(vector signed int, vector signed int)\nvector signed int vec_eqv(vector bool int, vector signed int)\nvector signed int vec_eqv(vector signed int, vector bool int)\nvector unsigned int vec_eqv(vector unsigned int, vector unsigned int)\nvector unsigned int vec_eqv(vector bool int, vector unsigned int)\nvector unsigned int vec_eqv(vector unsigned int, vector bool int)\nvector signed long long vec_eqv(vector signed long long, vector signed long long)\nvector signed long long vec_eqv(vector bool long long, vector signed long long)\nvector signed long long vec_eqv(vector signed long long, vector bool long long)\nvector unsigned long long vec_eqv(vector unsigned long long, vector unsigned long long)\nvector unsigned long long vec_eqv(vector bool long long, vector unsigned long long)\nvector unsigned long long vec_eqv(vector unsigned long long, vector bool long long)\nvector float vec_eqv(vector float, vector float)\nvector float vec_eqv(vector bool int, vector float)\nvector float vec_eqv(vector float, vector bool int)\nvector double vec_eqv(vector double, vector double)\nvector double vec_eqv(vector bool long long, vector double)\nvector double vec_eqv(vector double, vector bool long long)\nvector bool long long vec_perm(vector bool long long, vector bool long long, vector unsigned char)\nvector double vec_round(vector double)\nvector double vec_splat(vector double, const int)\nvector bool long long vec_splat(vector bool long long, const int)\nvector signed long long vec_splat(vector signed long long, const int)\nvector unsigned long long vec_splat(vector unsigned long long,\nvector bool int vec_sld(vector bool int, vector bool int, const int)\nvector bool short vec_sld(vector bool short, vector bool short, const int)\n\nllvm-svn: 241904"},

[d]={{"clang/lib/Basic/Targets/Mips.cpp",258,"bool MipsTargetInfo::validateTarget(DiagnosticsEngine &Diags) const {\n  // ...\n  // -mfp32 and n32/n64 ABIs are incompatible\n  if (FPMode != FP64 && FPMode != FPXX && !IsSingleFloat && (ABI == \"n32\" || ABI == \"n64\")) {\n    Diags.Report(diag::err_opt_not_valid_with_opt) << \"-mfpxx\" << CPU;"},{"clang/lib/Basic/Targets/Mips.cpp",264,"bool MipsTargetInfo::validateTarget(DiagnosticsEngine &Diags) const {\n  // ...\n  // Mips revision 6 and -mfp32 are incompatible\n  if (FPMode != FP64 && FPMode != FPXX && (CPU == \"mips32r6\" || CPU == \"mips64r6\")) {\n    Diags.Report(diag::err_opt_not_valid_with_opt) << \"-mfp32\" << CPU;"},{pb,459,"// Handle explicit options being passed to the compiler here: if we\'ve\n// explicitly turned off vsx and turned on any of:\n// - power8-vector\n// - direct-move\n// - float128\n// - power9-vector\n// - paired-vector-memops\n// - mma\n// - power10-vector\n// then go ahead and error since the customer has expressed an incompatible\n// set of options.\nstatic bool ppcUserFeaturesCheck(DiagnosticsEngine &Diags, const std::vector<std::string> &FeaturesVec) {\n  // ...\n  auto FindVSXSubfeature = [&](StringRef Feature, StringRef Option) {\n    if (llvm::is_contained(FeaturesVec, Feature)) {\n      Diags.Report(diag::err_opt_not_valid_with_opt) << Option << \"-mno-vsx\";"},{pb,593,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr7) && (ArchDefs & ArchDefinePpcgr) && llvm::is_contained(FeaturesVec, \"+float128\")) {\n    // ...\n    Diags.Report(diag::err_opt_not_valid_with_opt) << \"-mfloat128\" << CPU;"},{pb,600,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr10)) {\n    if (llvm::is_contained(FeaturesVec, \"+mma\")) {\n      // ...\n      Diags.Report(diag::err_opt_not_valid_with_opt) << \"-mmma\" << CPU;"},{pb,629,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr8) && llvm::is_contained(FeaturesVec, \"+rop-protect\")) {\n    // ...\n    Diags.Report(diag::err_opt_not_valid_with_opt) << \"-mrop-protect\" << CPU;"},{pb,635,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr8) && llvm::is_contained(FeaturesVec, \"+privileged\")) {\n    Diags.Report(diag::err_opt_not_valid_with_opt) << \"-mprivileged\" << CPU;"},{"clang/lib/Basic/Targets/WebAssembly.cpp",265,"bool WebAssemblyTargetInfo::handleTargetFeatures(std::vector<std::string> &Features, DiagnosticsEngine &Diags) {\n  for (const auto &Feature : Features) {\n    // ...\n    Diags.Report(diag::err_opt_not_valid_with_opt) << Feature << \"-target-feature\";"},{"clang/lib/Driver/Driver.cpp",3158,"/// Provides a convenient interface for different programming models to generate\n/// the required device actions.\nclass OffloadingActionBuilder final {\n  // ...\n  /// Base class for CUDA/HIP action builder. It injects device code in\n  /// the host backend action.\n  class CudaActionBuilderBase : public DeviceActionBuilder {\n    // ...\n    bool initialize() override {\n      // ...\n      // --offload and --offload-arch options are mutually exclusive.\n      if (Args.hasArgNoClaim(options::OPT_offload_EQ) && Args.hasArgNoClaim(options::OPT_offload_arch_EQ, options::OPT_no_offload_arch_EQ)) {\n        C.getDriver().Diag(diag::err_opt_not_valid_with_opt) << \"--offload-arch\""},{"clang/lib/Driver/Driver.cpp",3383,"/// Provides a convenient interface for different programming models to generate\n/// the required device actions.\nclass OffloadingActionBuilder final {\n  // ...\n  /// \\brief HIP action builder. It injects device code in the host backend\n  /// action.\n  class HIPActionBuilder final : public CudaActionBuilderBase {\n    // ...\n    HIPActionBuilder(Compilation &C, DerivedArgList &Args, const Driver::InputList &Inputs) : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_HIP) {\n      // ...\n      if (Args.hasArg(options::OPT_fhip_emit_relocatable, options::OPT_fno_hip_emit_relocatable)) {\n        // ...\n        if (*EmitReloc) {\n          if (Relocatable) {\n            C.getDriver().Diag(diag::err_opt_not_valid_with_opt) << \"-fhip-emit-relocatable\""},{"clang/lib/Driver/Driver.cpp",4411,"llvm::DenseSet<StringRef> Driver::getOffloadArchs(Compilation &C, const llvm::opt::DerivedArgList &Args, Action::OffloadKind Kind, const ToolChain *TC, bool SuppressError) const {\n  // ...\n  // --offload and --offload-arch options are mutually exclusive.\n  if (Args.hasArgNoClaim(options::OPT_offload_EQ) && Args.hasArgNoClaim(options::OPT_offload_arch_EQ, options::OPT_no_offload_arch_EQ)) {\n    C.getDriver().Diag(diag::err_opt_not_valid_with_opt) << \"--offload\" << (Args.hasArgNoClaim(options::OPT_offload_arch_EQ) ? \"--offload-arch\" : \"--no-offload-arch\");"},{"clang/lib/Driver/ToolChains/Arch/ARM.cpp",851,"llvm::ARM::FPUKind arm::getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector<StringRef> &Features, bool ForAS, bool ForMultilib) {\n  // ...\n  // Generate execute-only output (no data access to code sections).\n  // This only makes sense for the compiler, not for the assembler.\n  // It\'s not needed for multilib selection and may hide an unused\n  // argument diagnostic if the code is always run.\n  if (!ForAS && !ForMultilib) {\n    // Supported only on ARMv6T2 and ARMv7 and above.\n    // Cannot be combined with -mno-movt.\n    if (Arg *A = Args.getLastArg(options::OPT_mexecute_only, options::OPT_mno_execute_only)) {\n      if (A->getOption().matches(options::OPT_mexecute_only)) {\n        if (getARMSubArchVersionNumber(Triple) < 7 && llvm::ARM::parseArch(Triple.getArchName()) != llvm::ARM::ArchKind::ARMV6T2)\n        // ...\n        else if (Arg *B = Args.getLastArg(options::OPT_mno_movt))\n          D.Diag(diag::err_opt_not_valid_with_opt) << A->getAsString(Args) << B->getAsString(Args);"}}

[b]={{nil,K,"err_opt_not_valid_without_opt"}},

[j]={{nil,K,"option \'%0\' cannot be specified without \'%1\'"}},

[i]={{nil,K,"option \'A\' cannot be specified without \'B\'"}},

[h]=k,

[c]="option \'(.*?)\' cannot be specified without \'(.*?)\'",

[f]=a,

[e]={{nil,K,a}},

[g]={"57cc1a5d77d8",1515488039,"Added Control Flow Protection Flag","Added Control Flow Protection Flag\n\nCf-protection is a target independent flag that instructs the back-end to instrument control flow mechanisms like: Branch, Return, etc.\nFor example in X86 this flag will be used to instrument Indirect Branch Tracking instructions.\n\nDifferential Revision: https://reviews.llvm.org/D40478\n\nChange-Id: I5126e766c0e6b84118cae0ee8a20fe78cc373dea\nllvm-svn: 322063"},

[d]={{pb,606,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr10)) {\n    // ...\n    if (llvm::is_contained(FeaturesVec, \"+pcrel\")) {\n      // ...\n      Diags.Report(diag::err_opt_not_valid_without_opt) << \"-mpcrel\""},{pb,613,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr10)) {\n    // ...\n    if (llvm::is_contained(FeaturesVec, \"+prefixed\")) {\n      // ...\n      Diags.Report(diag::err_opt_not_valid_without_opt) << \"-mprefixed\""},{pb,619,"bool PPCTargetInfo::initFeatureMap(llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU, const std::vector<std::string> &FeaturesVec) const {\n  // ...\n  if (!(ArchDefs & ArchDefinePwr10)) {\n    // ...\n    if (llvm::is_contained(FeaturesVec, \"+paired-vector-memops\")) {\n      // ...\n      Diags.Report(diag::err_opt_not_valid_without_opt) << \"-mpaired-vector-memops\""},{"clang/lib/CodeGen/CodeGenFunction.cpp",1081,"#include \"clang/Basic/Sanitizers.def\"\n  // ...\n  // Since emitting the mcount call here impacts optimizations such as function\n  // inlining, we just add an attribute to insert a mcount call in backend.\n  // The attribute \"counting-function\" is set to mcount function name which is\n  // architecture dependent.\n  if (CGM.getCodeGenOpts().InstrumentForProfiling) {\n    // Calls to fentry/mcount should not be generated if function has\n    // the no_instrument_function attribute.\n    if (!CurFuncDecl || !CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) {\n      // ...\n      if (CGM.getCodeGenOpts().MNopMCount) {\n        if (!CGM.getCodeGenOpts().CallFEntry)\n          CGM.getDiags().Report(diag::err_opt_not_valid_without_opt) << \"-mnop-mcount\""},{"clang/lib/CodeGen/CodeGenFunction.cpp",1088,"#include \"clang/Basic/Sanitizers.def\"\n  // ...\n  // Since emitting the mcount call here impacts optimizations such as function\n  // inlining, we just add an attribute to insert a mcount call in backend.\n  // The attribute \"counting-function\" is set to mcount function name which is\n  // architecture dependent.\n  if (CGM.getCodeGenOpts().InstrumentForProfiling) {\n    // Calls to fentry/mcount should not be generated if function has\n    // the no_instrument_function attribute.\n    if (!CurFuncDecl || !CurFuncDecl->hasAttr<NoInstrumentFunctionAttr>()) {\n      // ...\n      if (CGM.getCodeGenOpts().RecordMCount) {\n        if (!CGM.getCodeGenOpts().CallFEntry)\n          CGM.getDiags().Report(diag::err_opt_not_valid_without_opt) << \"-mrecord-mcount\""},{"clang/lib/Driver/Driver.cpp",3389,"/// Provides a convenient interface for different programming models to generate\n/// the required device actions.\nclass OffloadingActionBuilder final {\n  // ...\n  /// \\brief HIP action builder. It injects device code in the host backend\n  /// action.\n  class HIPActionBuilder final : public CudaActionBuilderBase {\n    // ...\n    HIPActionBuilder(Compilation &C, DerivedArgList &Args, const Driver::InputList &Inputs) : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_HIP) {\n      // ...\n      if (Args.hasArg(options::OPT_fhip_emit_relocatable, options::OPT_fno_hip_emit_relocatable)) {\n        // ...\n        if (*EmitReloc) {\n          // ...\n          if (!CompileDeviceOnly) {\n            C.getDriver().Diag(diag::err_opt_not_valid_without_opt) << \"-fhip-emit-relocatable\""},{"clang/lib/Driver/ToolChains/Arch/ARM.cpp",807,"llvm::ARM::FPUKind arm::getARMTargetFeatures(const Driver &D, const llvm::Triple &Triple, const ArgList &Args, std::vector<StringRef> &Features, bool ForAS, bool ForMultilib) {\n  // ...\n  if (Arg *A = Args.getLastArg(options::OPT_mfix_cmse_cve_2021_35465, options::OPT_mno_fix_cmse_cve_2021_35465)) {\n    if (!Args.getLastArg(options::OPT_mcmse))\n      D.Diag(diag::err_opt_not_valid_without_opt) << A->getOption().getName() << \"-mcmse\";"}}

[b]="err_os_log_argument_too_big",

[j]="os_log() argument %0 is too big (%1 bytes, max %2)",

[i]="os_log() argument A is too big (B bytes, max C)",

[h]=k,

[c]="os_log\\(\\) argument (.*?) is too big \\((.*?) bytes, max (.*?)\\)",

[f]=a,

[e]=m,

[g]={"29034362ae87",1477328183,"Add support for __builtin_os_log_format[_buffer_size]","Add support for __builtin_os_log_format[_buffer_size]\n\nThese new builtins support a mechanism for logging OS events, using a\nprintf-like format string to specify the layout of data in a buffer.\nThe _buffer_size version of the builtin can be used to determine the size\nof the buffer to allocate to hold the data, and then __builtin_os_log_format\ncan write data into that buffer. This implements format checking to report\nmismatches between the format string and the data arguments. Most of this\ncode was written by Chris Willmore.\n\nDifferential Revision: https://reviews.llvm.org/D25888\n\nllvm-svn: 284990"},

[d]={{I,8743,"bool Sema::SemaBuiltinOSLogFormat(CallExpr *TheCall) {\n  // ...\n  while (i < NumArgs) {\n    // ...\n    if (ArgSize.getQuantity() >= 0x100) {\n      return Diag(Arg.get()->getEndLoc(), diag::err_os_log_argument_too_big) << i << (int)ArgSize.getQuantity() << 0xff << TheCall->getSourceRange();"}},

[b]="err_os_log_format_not_string_constant",

[j]="os_log() format argument is not a string constant",

[i]="os_log() format argument is not a string constant",

[h]=k,

[c]="os_log\\(\\) format argument is not a string constant",

[f]=a,

[e]=m,

[g]={"29034362ae87",1477328183,"Add support for __builtin_os_log_format[_buffer_size]","Add support for __builtin_os_log_format[_buffer_size]\n\nThese new builtins support a mechanism for logging OS events, using a\nprintf-like format string to specify the layout of data in a buffer.\nThe _buffer_size version of the builtin can be used to determine the size\nof the buffer to allocate to hold the data, and then __builtin_os_log_format\ncan write data into that buffer. This implements format checking to report\nmismatches between the format string and the data arguments. Most of this\ncode was written by Chris Willmore.\n\nDifferential Revision: https://reviews.llvm.org/D25888\n\nllvm-svn: 284990"},

[d]={{I,8014,"/// CheckObjCString - Checks that the format string argument to the os_log()\n/// and os_trace() functions is correct, and converts it to const char *.\nExprResult Sema::CheckOSLogFormatStringArg(Expr *Arg) {\n  // ...\n  if (!Literal || (!Literal->isOrdinary() && !Literal->isUTF8())) {\n    return ExprError(Diag(Arg->getBeginLoc(), diag::err_os_log_format_not_string_constant) << Arg->getSourceRange());"}},

[b]="err_out_of_line_constructor_template_id",

[j]="out-of-line constructor for %0 cannot have template arguments",

[i]="out-of-line constructor for A cannot have template arguments",

[h]=k,

[c]="out\\-of\\-line constructor for (.*?) cannot have template arguments",

[f]=a,

[e]=y,

[g]={"9de54ea41bdc",1263403896,"Reimplement constructor declarator parsing to cope with template-ids","Reimplement constructor declarator parsing to cope with template-ids\nthat name constructors, the endless joys of out-of-line constructor\ndefinitions, and various other corner cases that the previous hack\nnever imagined. Fixes PR5688 and tightens up semantic analysis for\nconstructor names.\n\nAdditionally, fixed a problem where we wouldn\'t properly enter the\ndeclarator scope of a parenthesized declarator. We were entering the\nscope, then leaving it when we saw the \")\"; now, we re-enter the\ndeclarator scope before parsing the parameter list.\n\nNote that we are forced to perform some tentative parsing within a\nclass (call it C) to tell the difference between\n\n  C(int); // constructor\n\nand\n\n  C (f)(int); // member function\n\nwhich is rather unfortunate. And, although it isn\'t necessary for\ncorrectness, we use the same tentative-parsing mechanism for\nout-of-line constructors to improve diagnostics in icky cases like:\n\n  C::C C::f(int); // error: C::C refers to the constructor name, but\n                  // we complain nicely and recover by treating it as\n                  // a type.\n\nllvm-svn: 93322"},

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

[b]="err_out_of_line_default_deletes",

[j]="defaulting this %select{default constructor|copy constructor|move constructor|copy assignment operator|move assignment operator|destructor}0 would delete it after its first declaration",

[i]={{nil,nil,{"defaulting this ",{"default constructor","copy constructor","move constructor","copy assignment operator","move assignment operator","destructor"}," would delete it after its first declaration"}}},

[h]=k,

[c]="defaulting this (?:default constructor|copy constructor|move constructor|copy assignment operator|move assignment operator|destructor) would delete it after its first declaration",

[f]=a,

[e]=m,

[g]={"b315302bf94a",1305172308,"Implement deletion of explicitly defaulted default constructors.","Implement deletion of explicitly defaulted default constructors.\n\nWe still don\'t parse out-of-line defaults correctly, which is needed to\nget the full effect out of this patch.\n\nllvm-svn: 131223"},

[d]={{w,7790,"bool Sema::CheckExplicitlyDefaultedSpecialMember(CXXMethodDecl *MD, CXXSpecialMember CSM, SourceLocation DefaultLoc) {\n  // ...\n  if (ShouldDeleteForTypeMismatch || ShouldDeleteSpecialMember(MD, CSM)) {\n    if (First) {\n    // ...\n    } else {\n      // ...\n      Diag(MD->getLocation(), diag::err_out_of_line_default_deletes) << CSM;"}},

[b]={{nil,n,"err_out_of_line_qualified_id_type_names_constructor"}},

[j]={{nil,n,"qualified reference to %0 is a constructor name rather than a %select{template name|type}1 in this context"}},

[i]={{nil,n,{"qualified reference to A is a constructor name rather than a ",{"template name","type"}," in this context"}}},

[h]=k,

[c]="qualified reference to (.*?) is a constructor name rather than a (?:template name|type) in this context",

[f]=a,

[e]={{nil,n,m}},

[g]={"74f02347ca16",1484859613,"PR13403 (+duplicates): implement C++ DR1310 (http://wg21.link/cwg1310).","PR13403 (+duplicates): implement C++ DR1310 (http://wg21.link/cwg1310).\n\nUnder this defect resolution, the injected-class-name of a class or class\ntemplate cannot be used except in very limited circumstances (when declaring a\nconstructor, in a nested-name-specifier, in a base-specifier, or in an\nelaborated-type-specifier). This is apparently done to make parsing easier, but\nit\'s a pain for us since we don\'t know whether a template-id using the\ninjected-class-name is valid at the point when we annotate it (we don\'t yet\nknow whether the template-id will become part of an elaborated-type-specifier).\n\nAs a tentative resolution to a perceived language defect, mem-initializer-ids\nare added to the list of exceptions here (they generally follow the same rules\nas base-specifiers).\n\nWhen the reference to the injected-class-name uses the \'typename\' or \'template\'\nkeywords, we permit it to be used to name a type or template as an extension;\nother compilers also accept some cases in this area. There are also a couple of\ncorner cases with dependent template names that we do not yet diagnose, but\nwhich will also get this treatment.\n\nllvm-svn: 292518"},

[d]={{D,548,"/// If the identifier refers to a type name within this scope,\n/// return the declaration of that type.\n///\n/// This routine performs ordinary name lookup of the identifier II\n/// within the given scope, with optional C++ scope specifier SS, to\n/// determine whether the name refers to a type. If so, returns an\n/// opaque pointer (actually a QualType) corresponding to that\n/// type. Otherwise, returns NULL.\nParsedType Sema::getTypeName(const IdentifierInfo &II, SourceLocation NameLoc, Scope *S, CXXScopeSpec *SS, bool isClassName, bool HasTrailingDot, ParsedType ObjectTypePtr, bool IsCtorOrDtorName, bool WantNontrivialTypeSourceInfo, bool IsClassTemplateDeductionContext, ImplicitTypenameContext AllowImplicitTypename, IdentifierInfo **CorrectedII) {\n  // ...\n  if (TypeDecl *TD = dyn_cast<TypeDecl>(IIDecl)) {\n    // ...\n    if (!isClassName && !IsCtorOrDtorName && LookupRD && FoundRD && FoundRD->isInjectedClassName() && declaresSameEntity(LookupRD, cast<Decl>(FoundRD->getParent())))\n      Diag(NameLoc, diag::err_out_of_line_qualified_id_type_names_constructor) << &II << /*Type*/ 1;"},{W,4172,"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  // ...\n  if (!IsCtorOrDtorName && !IsClassName && SS.isSet()) {\n    // ...\n    if (LookupRD && LookupRD->getIdentifier() == TemplateII) {\n      Diag(TemplateIILoc, TemplateKWLoc.isInvalid() ? diag::err_out_of_line_qualified_id_type_names_constructor : diag::ext_out_of_line_qualified_id_type_names_constructor) << TemplateII << 0 /*injected-class-name used as template name*/"}},

[b]={{nil,F,"err_overflow_builtin_bit_int_max_size"}},

[j]={{nil,F,"__builtin_mul_overflow does not support \'signed _BitInt\' operands of more than %0 bits"}},

[i]={{nil,F,"__builtin_mul_overflow does not support \'signed _BitInt\' operands of more than A bits"}},

[h]=k,

[c]="__builtin_mul_overflow does not support \'signed _BitInt\' operands of more than (.*?) bits",

[f]=a,

[e]={{nil,F,m}},

[g]={"f9c3310d32c6",1616787805,"[OPENMP]Fix PR49366: crash on VLAs in task untied regions.","[OPENMP]Fix PR49366: crash on VLAs in task untied regions.\n\nWe need to capture the local variables into a record in task untied\nregions but clang does not support record with VLA data members.\n\nDifferential Revision: https://reviews.llvm.org/D99436"},

[d]={{I,417,"static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID) {\n  // ...\n  // Disallow signed bit-precise integer args larger than 128 bits to mul\n  // function until we improve backend support.\n  if (BuiltinID == Builtin::BI__builtin_mul_overflow) {\n    for (unsigned I = 0; I < 3; ++I) {\n      // ...\n      if (Ty->isBitIntType() && Ty->isSignedIntegerType() && S.getASTContext().getIntWidth(Ty) > 128)\n        return S.Diag(Arg->getBeginLoc(), diag::err_overflow_builtin_bit_int_max_size) << 128;"}},

[b]="err_overflow_builtin_must_be_int",

[j]="operand argument to overflow builtin must be an integer (%0 invalid)",

[i]="operand argument to overflow builtin must be an integer (A invalid)",

[h]=k,

[c]="operand argument to overflow builtin must be an integer \\((.*?) invalid\\)",

[f]=a,

[e]=m,

[g]={"03107a4ef015",1446151681,"Add support for __builtin_{add,sub,mul}_overflow.","Add support for __builtin_{add,sub,mul}_overflow.\n\nPatch by David Grayson!\n\nllvm-svn: 251651"},

[d]={{I,381,"static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID) {\n  // ...\n  // First two arguments should be integers.\n  for (unsigned I = 0; I < 2; ++I) {\n    // ...\n    if (!Ty->isIntegerType()) {\n      S.Diag(Arg.get()->getBeginLoc(), diag::err_overflow_builtin_must_be_int) << Ty << Arg.get()->getSourceRange();"}},

[b]="err_overflow_builtin_must_be_ptr_int",

[j]="result argument to overflow builtin must be a pointer to a non-const integer (%0 invalid)",

[i]="result argument to overflow builtin must be a pointer to a non-const integer (A invalid)",

[h]=k,

[c]="result argument to overflow builtin must be a pointer to a non\\-const integer \\((.*?) invalid\\)",

[f]=a,

[e]=m,

[g]={"03107a4ef015",1446151681,"Add support for __builtin_{add,sub,mul}_overflow.","Add support for __builtin_{add,sub,mul}_overflow.\n\nPatch by David Grayson!\n\nllvm-svn: 251651"},

[d]={{I,401,"static bool SemaBuiltinOverflow(Sema &S, CallExpr *TheCall, unsigned BuiltinID) {\n  // ...\n  // Third argument should be a pointer to a non-const integer.\n  // IRGen correctly handles volatile, restrict, and address spaces, and\n  // the other qualifiers aren\'t possible.\n  {\n    // ...\n    if (!PtrTy || !PtrTy->getPointeeType()->isIntegerType() || PtrTy->getPointeeType().isConstQualified()) {\n      S.Diag(Arg.get()->getBeginLoc(), diag::err_overflow_builtin_must_be_ptr_int) << Ty << Arg.get()->getSourceRange();"}},

[b]="err_override_control_interface",

[j]="\'%0\' keyword not permitted with interface types",

[i]="\'A\' keyword not permitted with interface types",

[h]=k,

[c]="\'(.*?)\' keyword not permitted with interface types",

[f]=a,

[e]=y,

[g]={"db632ac004ae",1348558359,"Fix for r163013 regression and further __interface enhancement.","Fix for r163013 regression and further __interface enhancement.\nPatch by Andy Gibbs!\n\nllvm-svn: 164590"},

[d]={{kc,2462,"/// ParseOptionalCXX11VirtSpecifierSeq - Parse a virt-specifier-seq.\n///\n///      virt-specifier-seq:\n///        virt-specifier\n///        virt-specifier-seq virt-specifier\nvoid Parser::ParseOptionalCXX11VirtSpecifierSeq(VirtSpecifiers &VS, bool IsInterface, SourceLocation FriendLoc) {\n  while (true) {\n    // ...\n    if (IsInterface && (Specifier == VirtSpecifiers::VS_Final || Specifier == VirtSpecifiers::VS_Sealed)) {\n      Diag(Tok.getLocation(), diag::err_override_control_interface) << VirtSpecifiers::getSpecifierName(Specifier);"},{kc,3524,"/// ParseCXXMemberSpecification - Parse the class definition.\n///\n///      member-specification:\n///        member-declaration member-specification[opt]\n///        access-specifier \':\' member-specification[opt]\n///\nvoid Parser::ParseCXXMemberSpecification(SourceLocation RecordLoc, SourceLocation AttrFixitLoc, ParsedAttributes &Attrs, unsigned TagType, Decl *TagDecl) {\n  // ...\n  // Parse the optional \'final\' keyword.\n  if (getLangOpts().CPlusPlus && Tok.is(tok::identifier)) {\n    while (true) {\n      // ...\n      if (TagType == DeclSpec::TST_interface)\n        Diag(FinalLoc, diag::err_override_control_interface) << VirtSpecifiers::getSpecifierName(Specifier);"}},

[b]="err_override_exception_spec",

[j]="exception specification of overriding function is more lax than base version",

[i]="exception specification of overriding function is more lax than base version",

[h]=k,

[c]="exception specification of overriding function is more lax than base version",

[f]=a,

[e]=m,

[g]={"86be854fa869",1246998597,"Implement checking of exception spec compatibility for overriding virtual functions.","Implement checking of exception spec compatibility for overriding virtual functions.\n\nllvm-svn: 74943"},

[d]={{"clang/lib/Sema/SemaExceptionSpec.cpp",990,"bool Sema::CheckOverridingFunctionExceptionSpec(const CXXMethodDecl *New, const CXXMethodDecl *Old) {\n  // ...\n  unsigned DiagID = diag::err_override_exception_spec;"}},

[b]="err_ovl_ambiguous_call",

[j]="call to %0 is ambiguous",

[i]="call to A is ambiguous",

[h]=k,

[c]="call to (.*?) is ambiguous",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{Q,2617,"static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl<Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose) {\n  // ...\n  case OR_Ambiguous:\n    if (Diagnose) {\n      Candidates.NoteCandidates(PartialDiagnosticAt(R.getNameLoc(), S.PDiag(diag::err_ovl_ambiguous_call) << R.getLookupName() << Range), S, OCD_AmbiguousCandidates, Args);"},{Q,3881,"static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator) {\n  // ...\n  case OR_Ambiguous:\n    Candidates.NoteCandidates(PartialDiagnosticAt(R.getNameLoc(), S.PDiag(diag::err_ovl_ambiguous_call) << R.getLookupName() << Range), S, OCD_AmbiguousCandidates, Args);"},{"clang/lib/Sema/SemaLookup.cpp",3764,"/// LookupLiteralOperator - Determine which literal operator should be used for\n/// a user-defined literal, per C++11 [lex.ext].\n///\n/// Normal overload resolution is not used to select which literal operator to\n/// call for a user-defined literal. Look up the provided literal operator name,\n/// and filter the results to the appropriate set for the given argument types.\nSema::LiteralOperatorLookupResult Sema::LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplatePack, bool DiagnoseMissing, StringLiteral *StringLit) {\n  // ...\n  // C++11 [lex.ext]p3, p4: S shall contain a raw literal operator or a literal\n  // operator template, but not both.\n  if (FoundRaw && FoundTemplate) {\n    Diag(R.getNameLoc(), diag::err_ovl_ambiguous_call) << R.getLookupName();"},{E,13536,"/// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns\n/// the completed call expression. If overload resolution fails, emits\n/// diagnostics and returns ExprError()\nstatic ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, OverloadCandidateSet *CandidateSet, OverloadCandidateSet::iterator *Best, OverloadingResult OverloadResult, bool AllowTypoCorrection) {\n  // ...\n  case OR_Ambiguous:\n    CandidateSet->NoteCandidates(PartialDiagnosticAt(Fn->getBeginLoc(), SemaRef.PDiag(diag::err_ovl_ambiguous_call) << ULE->getName() << Fn->getSourceRange()), SemaRef, OCD_AmbiguousCandidates, Args);"},{E,15371,"/// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to\n/// a literal operator described by the provided lookup results.\nExprResult Sema::BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef<Expr *> Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *TemplateArgs) {\n  // ...\n  case OR_Ambiguous:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(R.getNameLoc(), PDiag(diag::err_ovl_ambiguous_call) << R.getLookupName()), *this, OCD_AmbiguousCandidates, Args);"}},

[b]="err_ovl_ambiguous_conversion_in_cast",

[j]={{nil,t,"ambiguous conversion for %select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|functional-style cast|}0 from %1 to %2"},{o,nil,"ambiguous conversion for %select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|functional-style cast}0 from %1 to %2"}},

[i]={{nil,t,{"ambiguous conversion for ",{a,xb,Nb,Qb,Mb,Sb,a}," from B to C"}},{o,nil,{"ambiguous conversion for ",{a,xb,Nb,Qb,Mb,Sb}," from B to C"}}},

[h]=k,

[c]="ambiguous conversion for (?:|static_cast|reinterpret_cast|dynamic_cast|C\\-style cast|functional\\-style cast|) from (.*?) to (.*?)",

[f]=a,

[e]=m,

[g]={"909acf820969",1297708450,"Provide overload diagnostics when explicit casts involving class types fail.","Provide overload diagnostics when explicit casts involving class types fail.\nPR8626.\n\nllvm-svn: 125506"},

[d]={{"clang/lib/Sema/SemaCast.cpp",498,"/// Try to diagnose a failed overloaded cast.  Returns true if\n/// diagnostics were emitted.\nstatic bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, SourceRange range, Expr *src, QualType destType, bool listInitialization) {\n  // ...\n  case OR_Ambiguous:\n    msg = diag::err_ovl_ambiguous_conversion_in_cast;"}},

[b]="err_ovl_ambiguous_init",

[j]="call to constructor of %0 is ambiguous",

[i]="call to constructor of A is ambiguous",

[h]=k,

[c]="call to constructor of (.*?) is ambiguous",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{P,9857,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  // ...\n  case FK_ListConstructorOverloadFailed:\n  case FK_ConstructorOverloadFailed: {\n    // ...\n    case OR_Ambiguous:\n      FailedCandidateSet.NoteCandidates(PartialDiagnosticAt(Kind.getLocation(), S.PDiag(diag::err_ovl_ambiguous_init) << DestType << ArgsRange), S, OCD_AmbiguousCandidates, Args);"}},

[b]="err_ovl_ambiguous_member_call",

[j]="call to member function %0 is ambiguous",

[i]="call to member function A is ambiguous",

[h]=k,

[c]="call to member function (.*?) is ambiguous",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,14831,"/// BuildCallToMemberFunction - Build a call to a member\n/// function. MemExpr is the expression that refers to the member\n/// function (and includes the object parameter), Args/NumArgs are the\n/// arguments to the function call (not including the object\n/// parameter). The caller needs to validate that the member\n/// expression refers to a non-static member function or an overloaded\n/// member function.\nExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n  // ...\n  if (isa<MemberExpr>(NakedMemExpr)) {\n  // ...\n  } else {\n    // ...\n    case OR_Ambiguous:\n      CandidateSet.NoteCandidates(PartialDiagnosticAt(UnresExpr->getMemberLoc(), PDiag(diag::err_ovl_ambiguous_member_call) << DeclName << MemExprE->getSourceRange()), *this, OCD_AmbiguousCandidates, Args);"}},

[b]="err_ovl_ambiguous_object_call",

[j]="call to object of type %0 is ambiguous",

[i]="call to object of type A is ambiguous",

[h]=k,

[c]="call to object of type (.*?) is ambiguous",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,15081,"/// BuildCallToObjectOfClassType - Build a call to an object of class\n/// type (C++ [over.call.object]), which can end up invoking an\n/// overloaded function call operator (@c operator()) or performing a\n/// user-defined conversion on the object argument.\nExprResult Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc) {\n  // ...\n  case OR_Ambiguous:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(Object.get()->getBeginLoc(), PDiag(diag::err_ovl_ambiguous_object_call) << Object.get()->getType() << Object.get()->getSourceRange()), *this, OCD_AmbiguousCandidates, Args);"}},

[b]="err_ovl_ambiguous_oper_binary",

[j]="use of overloaded operator \'%0\' is ambiguous (with operand types %1 and %2)",

[i]="use of overloaded operator \'A\' is ambiguous (with operand types B and C)",

[h]=k,

[c]="use of overloaded operator \'(.*?)\' is ambiguous \\(with operand types (.*?) and (.*?)\\)",

[f]=a,

[e]=m,

[g]={"052caec1f3ff",1289678798,"When complaining about ambiguous overload resolution for a unary or","When complaining about ambiguous overload resolution for a unary or\nbinary operator, provide the types.\n\nllvm-svn: 119008"},

[d]={{E,14284,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  // ...\n  case OR_Ambiguous:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_binary) << BinaryOperator::getOpcodeStr(Opc) << Args[0]->getType() << Args[1]->getType() << Args[0]->getSourceRange() << Args[1]->getSourceRange()), *this, OCD_AmbiguousCandidates, Args, BinaryOperator::getOpcodeStr(Opc), OpLoc);"},{E,14618,"ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg ArgExpr) {\n  // ...\n  case OR_Ambiguous:\n    if (Args.size() == 2) {\n      CandidateSet.NoteCandidates(PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary) << \"[]\" << Args[0]->getType() << Args[1]->getType() << Args[0]->getSourceRange() << Range), *this, OCD_AmbiguousCandidates, Args, \"[]\", LLoc);"}},

[b]="err_ovl_ambiguous_oper_unary",

[j]="use of overloaded operator \'%0\' is ambiguous (operand type %1)",

[i]="use of overloaded operator \'A\' is ambiguous (operand type B)",

[h]=k,

[c]="use of overloaded operator \'(.*?)\' is ambiguous \\(operand type (.*?)\\)",

[f]=a,

[e]=m,

[g]={"052caec1f3ff",1289678798,"When complaining about ambiguous overload resolution for a unary or","When complaining about ambiguous overload resolution for a unary or\nbinary operator, provide the types.\n\nllvm-svn: 119008"},

[d]={{E,13796,"/// Create a unary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'*\').\n///\n/// \\param Opc The UnaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedUnaryOp().\n///\n/// \\param Input The input argument.\nExprResult Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *Input, bool PerformADL) {\n  // ...\n  case OR_Ambiguous:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary) << UnaryOperator::getOpcodeStr(Opc) << Input->getType() << Input->getSourceRange()), *this, OCD_AmbiguousCandidates, ArgsArray, UnaryOperator::getOpcodeStr(Opc), OpLoc);"},{E,15289,"/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->\n///  (if one exists), where @c Base is an expression of class type and\n/// @c Member is the name of the member we\'re trying to find.\nExprResult Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound) {\n  // ...\n  case OR_Ambiguous:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary) << \"->\" << Base->getType() << Base->getSourceRange()), *this, OCD_AmbiguousCandidates, Base);"}},

[b]={{nil,C,"err_ovl_ambiguous_subscript_call"}},

[j]={{nil,C,"call to subscript operator of type %0 is ambiguous"}},

[i]={{nil,C,"call to subscript operator of type A is ambiguous"}},

[h]=k,

[c]="call to subscript operator of type (.*?) is ambiguous",

[f]=a,

[e]={{nil,C,m}},

[g]={"f9c3310d32c6",1616787805,"[OPENMP]Fix PR49366: crash on VLAs in task untied regions.","[OPENMP]Fix PR49366: crash on VLAs in task untied regions.\n\nWe need to capture the local variables into a record in task untied\nregions but clang does not support record with VLA data members.\n\nDifferential Revision: https://reviews.llvm.org/D99436"},

[d]={{E,14625,"ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg ArgExpr) {\n  // ...\n  case OR_Ambiguous:\n    if (Args.size() == 2) {\n    // ...\n    } else {\n      CandidateSet.NoteCandidates(PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_ambiguous_subscript_call) << Args[0]->getType() << Args[0]->getSourceRange() << Range), *this, OCD_AmbiguousCandidates, Args, \"[]\", LLoc);"}},

[b]="err_ovl_deleted_call",

[j]={{nil,x,"call to deleted function %0"},{u,nil,"call to %select{unavailable|deleted}0 function %1%2"}},

[i]={{nil,x,"call to deleted function A"},{u,nil,{"call to ",{Zb,ac}," function BC"}}},

[h]=k,

[c]="call to deleted function (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{"clang/lib/ARCMigrate/TransGCCalls.cpp",56,"class GCCollectableCallsChecker : public RecursiveASTVisitor<GCCollectableCallsChecker> {\n  // ...\n  bool VisitCallExpr(CallExpr *E) {\n    // ...\n    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CEE)) {\n      if (FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(DRE->getDecl())) {\n        // ...\n        if (FD->getIdentifier() == NSMakeCollectableII) {\n          // ...\n          TA.clearDiagnostic(diag::err_unavailable, diag::err_unavailable_message,\n                            diag::err_ovl_deleted_call, // ObjC++"},{Q,2627,"static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl<Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose) {\n  // ...\n  case OR_Deleted: {\n    if (Diagnose) {\n      Candidates.NoteCandidates(PartialDiagnosticAt(R.getNameLoc(), S.PDiag(diag::err_ovl_deleted_call) << R.getLookupName() << Range), S, OCD_AllCandidates, Args);"},{Q,3888,"static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator) {\n  // ...\n  case OR_Deleted: {\n    Candidates.NoteCandidates(PartialDiagnosticAt(R.getNameLoc(), S.PDiag(diag::err_ovl_deleted_call) << R.getLookupName() << Range), S, OCD_AllCandidates, Args);"},{E,13544,"/// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns\n/// the completed call expression. If overload resolution fails, emits\n/// diagnostics and returns ExprError()\nstatic ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, OverloadCandidateSet *CandidateSet, OverloadCandidateSet::iterator *Best, OverloadingResult OverloadResult, bool AllowTypoCorrection) {\n  // ...\n  case OR_Deleted: {\n    CandidateSet->NoteCandidates(PartialDiagnosticAt(Fn->getBeginLoc(), SemaRef.PDiag(diag::err_ovl_deleted_call) << ULE->getName() << Fn->getSourceRange()), SemaRef, OCD_AllCandidates, Args);"}},

[b]={{nil,o,"err_ovl_deleted_comparison"}},

[j]={{nil,o,"object of type %0 cannot be compared because its %1 is implicitly deleted"}},

[i]={{nil,o,"object of type A cannot be compared because its B is implicitly deleted"}},

[h]=k,

[c]="object of type (.*?) cannot be compared because its (.*?) is implicitly deleted",

[f]=a,

[e]={{nil,o,m}},

[g]={"5253d9138eb3",1573070592,"[c++20] Determine whether a defaulted comparison should be deleted or","[c++20] Determine whether a defaulted comparison should be deleted or\nconstexpr."},

[d]={{E,14303,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  // ...\n  case OR_Deleted:\n    if (isImplicitlyDeleted(Best->Function)) {\n      // ...\n      if (DFK.isSpecialMember()) {\n      // ...\n      } else {\n        // ...\n        Diag(OpLoc, diag::err_ovl_deleted_comparison) << Args[0]->getType() << DeletedFD;"}},

[b]="err_ovl_deleted_conversion_in_cast",

[j]={{nil,t,"%select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|functional-style cast|}0 from %1 to %2 uses deleted function"},{o,nil,"%select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|functional-style cast}0 from %1 to %2 uses deleted function"}},

[i]={{nil,t,{{a,xb,Nb,Qb,Mb,Sb,a}," from B to C uses deleted function"}},{o,nil,{{a,xb,Nb,Qb,Mb,Sb}," from B to C uses deleted function"}}},

[h]=k,

[c]="(?:|static_cast|reinterpret_cast|dynamic_cast|C\\-style cast|functional\\-style cast|) from (.*?) to (.*?) uses deleted function",

[f]=a,

[e]=m,

[g]={"909acf820969",1297708450,"Provide overload diagnostics when explicit casts involving class types fail.","Provide overload diagnostics when explicit casts involving class types fail.\nPR8626.\n\nllvm-svn: 125506"},

[d]={{"clang/lib/Sema/SemaCast.cpp",503,"/// Try to diagnose a failed overloaded cast.  Returns true if\n/// diagnostics were emitted.\nstatic bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, SourceRange range, Expr *src, QualType destType, bool listInitialization) {\n  // ...\n  case OR_Deleted:\n    msg = diag::err_ovl_deleted_conversion_in_cast;"}},

[b]="err_ovl_deleted_init",

[j]={{nil,x,"call to deleted constructor of %0"},{u,nil,"call to %select{unavailable|deleted}0 constructor of %1"}},

[i]={{nil,x,"call to deleted constructor of A"},{u,nil,{"call to ",{Zb,ac}," constructor of B"}}},

[h]=k,

[c]="call to deleted constructor of (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{P,9922,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  // ...\n  case FK_ListConstructorOverloadFailed:\n  case FK_ConstructorOverloadFailed: {\n    // ...\n    case OR_Deleted: {\n      // ...\n      if (Ovl != OR_Deleted) {\n        S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init) << DestType << ArgsRange;"},{P,9936,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  // ...\n  case FK_ListConstructorOverloadFailed:\n  case FK_ConstructorOverloadFailed: {\n    // ...\n    case OR_Deleted: {\n      // ...\n      // If this is a defaulted or implicitly-declared function, then\n      // it was implicitly deleted. Make it clear that the deletion was\n      // implicit.\n      if (S.isImplicitlyDeleted(Best->Function))\n      // ...\n      else\n        S.Diag(Kind.getLocation(), diag::err_ovl_deleted_init) << DestType << ArgsRange;"}},

[b]="err_ovl_deleted_member_call",

[j]={{nil,x,"call to deleted member function %0"},{u,nil,"call to %select{unavailable|deleted}0 member function %1%2"}},

[i]={{nil,x,"call to deleted member function A"},{u,nil,{"call to ",{Zb,ac}," member function BC"}}},

[h]=k,

[c]="call to deleted member function (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,14838,"/// BuildCallToMemberFunction - Build a call to a member\n/// function. MemExpr is the expression that refers to the member\n/// function (and includes the object parameter), Args/NumArgs are the\n/// arguments to the function call (not including the object\n/// parameter). The caller needs to validate that the member\n/// expression refers to a non-static member function or an overloaded\n/// member function.\nExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n  // ...\n  if (isa<MemberExpr>(NakedMemExpr)) {\n  // ...\n  } else {\n    // ...\n    case OR_Deleted:\n      CandidateSet.NoteCandidates(PartialDiagnosticAt(UnresExpr->getMemberLoc(), PDiag(diag::err_ovl_deleted_member_call) << DeclName << MemExprE->getSourceRange()), *this, OCD_AllCandidates, Args);"}},

[b]="err_ovl_deleted_object_call",

[j]={{nil,x,"call to deleted function call operator in type %0"},{u,nil,"call to %select{unavailable|deleted}0 function call operator in type %1%2"}},

[i]={{nil,x,"call to deleted function call operator in type A"},{u,nil,{"call to ",{Zb,ac}," function call operator in type BC"}}},

[h]=k,

[c]="call to deleted function call operator in type (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,15090,"/// BuildCallToObjectOfClassType - Build a call to an object of class\n/// type (C++ [over.call.object]), which can end up invoking an\n/// overloaded function call operator (@c operator()) or performing a\n/// user-defined conversion on the object argument.\nExprResult Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc) {\n  // ...\n  case OR_Deleted:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(Object.get()->getBeginLoc(), PDiag(diag::err_ovl_deleted_object_call) << Object.get()->getType() << Object.get()->getSourceRange()), *this, OCD_AllCandidates, Args);"}}

[b]="err_ovl_deleted_oper",

[j]={{nil,x,"overload resolution selected deleted operator \'%0\'"},{u,nil,"overload resolution selected %select{unavailable|deleted}0 operator \'%1\'%2"}},

[i]={{nil,x,"overload resolution selected deleted operator \'A\'"},{u,nil,{"overload resolution selected ",{Zb,ac}," operator \'B\'C"}}},

[h]=k,

[c]="overload resolution selected deleted operator \'(.*?)\'",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,13805,"/// Create a unary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'*\').\n///\n/// \\param Opc The UnaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedUnaryOp().\n///\n/// \\param Input The input argument.\nExprResult Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *Input, bool PerformADL) {\n  // ...\n  case OR_Deleted:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper) << UnaryOperator::getOpcodeStr(Opc) << Input->getSourceRange()), *this, OCD_AllCandidates, ArgsArray, UnaryOperator::getOpcodeStr(Opc), OpLoc);"},{E,14314,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  // ...\n  case OR_Deleted:\n    // ...\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper) << getOperatorSpelling(Best->Function->getDeclName().getCXXOverloadedOperator()) << Args[0]->getSourceRange() << Args[1]->getSourceRange()), *this, OCD_AllCandidates, Args, BinaryOperator::getOpcodeStr(Opc), OpLoc);"},{E,14634,"ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg ArgExpr) {\n  // ...\n  case OR_Deleted:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_deleted_oper) << \"[]\" << Args[0]->getSourceRange() << Range), *this, OCD_AllCandidates, Args, \"[]\", LLoc);"},{E,15297,"/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->\n///  (if one exists), where @c Base is an expression of class type and\n/// @c Member is the name of the member we\'re trying to find.\nExprResult Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound) {\n  // ...\n  case OR_Deleted:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper) << \"->\" << Base->getSourceRange()), *this, OCD_AllCandidates, Base);"}},

[b]="err_ovl_deleted_special_init",

[j]="call to implicitly-deleted %select{default constructor|copy constructor|move constructor|copy assignment operator|move assignment operator|destructor|function}0 of %1",

[i]={{nil,nil,{"call to implicitly-deleted ",{"default constructor","copy constructor","move constructor","copy assignment operator","move assignment operator","destructor","function"}," of B"}}},

[h]=k,

[c]="call to implicitly\\-deleted (?:default constructor|copy constructor|move constructor|copy assignment operator|move assignment operator|destructor|function) of (.*?)",

[f]=a,

[e]=m,

[g]={"74f7d50f6a5b",1329334432,"When overload resolution picks an implicitly-deleted special member","When overload resolution picks an implicitly-deleted special member\nfunction, provide a specialized diagnostic that indicates the kind of\nspecial member function (default constructor, copy assignment\noperator, etc.) and that it was implicitly deleted. Add a hook where\nwe can provide more detailed information later.\n\nllvm-svn: 150611"},

[d]={{P,9932,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  // ...\n  case FK_ListConstructorOverloadFailed:\n  case FK_ConstructorOverloadFailed: {\n    // ...\n    case OR_Deleted: {\n      // ...\n      // If this is a defaulted or implicitly-declared function, then\n      // it was implicitly deleted. Make it clear that the deletion was\n      // implicit.\n      if (S.isImplicitlyDeleted(Best->Function))\n        S.Diag(Kind.getLocation(), diag::err_ovl_deleted_special_init) << S.getSpecialMember(cast<CXXMethodDecl>(Best->Function)) << DestType << ArgsRange;"}},

[b]="err_ovl_deleted_special_oper",

[j]="object of type %0 cannot be %select{constructed|copied|moved|assigned|assigned|destroyed}1 because its %select{default constructor|copy constructor|move constructor|copy assignment operator|move assignment operator|destructor}1 is implicitly deleted",

[i]={{nil,nil,{"object of type A cannot be ",{"constructed","copied","moved","assigned","assigned","destroyed"}," because its ",{"default constructor","copy constructor","move constructor","copy assignment operator","move assignment operator","destructor"}," is implicitly deleted"}}},

[h]=k,

[c]="object of type (.*?) cannot be (?:constructed|copied|moved|assigned|assigned|destroyed) because its (?:default constructor|copy constructor|move constructor|copy assignment operator|move assignment operator|destructor) is implicitly deleted",

[f]=a,

[e]=m,

[g]={"74f7d50f6a5b",1329334432,"When overload resolution picks an implicitly-deleted special member","When overload resolution picks an implicitly-deleted special member\nfunction, provide a specialized diagnostic that indicates the kind of\nspecial member function (default constructor, copy assignment\noperator, etc.) and that it was implicitly deleted. Add a hook where\nwe can provide more detailed information later.\n\nllvm-svn: 150611"},

[d]={{E,14299,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  // ...\n  case OR_Deleted:\n    if (isImplicitlyDeleted(Best->Function)) {\n      // ...\n      if (DFK.isSpecialMember()) {\n        Diag(OpLoc, diag::err_ovl_deleted_special_oper) << Args[0]->getType() << DFK.asSpecialMember();"}},

[b]="err_ovl_diff_return_type",

[j]="functions that differ only in their return type cannot be overloaded",

[i]="functions that differ only in their return type cannot be overloaded",

[h]=k,

[c]="functions that differ only in their return type cannot be overloaded",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{D,3939,"/// 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  // ...\n  if (getLangOpts().CPlusPlus) {\n    // ...\n    if (!Context.hasSameType(OldDeclaredReturnType, NewDeclaredReturnType) && canFullyTypeCheckRedeclaration(New, Old, NewDeclaredReturnType, OldDeclaredReturnType)) {\n      // ...\n      if (ResQT.isNull()) {\n        if (New->isCXXClassMember() && New->isOutOfLine())\n        // ...\n        else\n          Diag(New->getLocation(), diag::err_ovl_diff_return_type) << New->getReturnTypeSourceRange();"}},

[b]="err_ovl_no_conversion_in_cast",

[j]="cannot convert %1 to %2 without a conversion operator",

[i]="cannot convert B to C without a conversion operator",

[h]=k,

[c]="cannot convert (.*?) to (.*?) without a conversion operator",

[f]=a,

[e]=m,

[g]={"909acf820969",1297708450,"Provide overload diagnostics when explicit casts involving class types fail.","Provide overload diagnostics when explicit casts involving class types fail.\nPR8626.\n\nllvm-svn: 125506"},

[d]={{"clang/lib/Sema/SemaCast.cpp",491,"/// Try to diagnose a failed overloaded cast.  Returns true if\n/// diagnostics were emitted.\nstatic bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, SourceRange range, Expr *src, QualType destType, bool listInitialization) {\n  // ...\n  case OR_No_Viable_Function:\n    if (candidates.empty())\n      msg = diag::err_ovl_no_conversion_in_cast;"}},

[b]="err_ovl_no_oper",

[j]="type %0 does not provide a %select{subscript|call}1 operator",

[i]={{nil,nil,{"type A does not provide a ",{"subscript","call"}," operator"}}},

[h]=k,

[c]="type (.*?) does not provide a (?:subscript|call) operator",

[f]=a,

[e]=m,

[g]={"0237485287e9",1262829855,"Improve the lead diagnostic for C++ object subscript expressions with","Improve the lead diagnostic for C++ object subscript expressions with\nno viable overloads.  Use a different message when the class provides\nno operator[] overloads at all; use it for operator(), too.\n\nPartially addresses PR 5900.\n\nllvm-svn: 92894"},

[d]={{E,14604,"ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, SourceLocation RLoc, Expr *Base, MultiExprArg ArgExpr) {\n  // ...\n  case OR_No_Viable_Function: {\n    PartialDiagnostic PD = CandidateSet.empty() ? (PDiag(diag::err_ovl_no_oper) << Args[0]->getType() << /*subscript*/ 0 << Args[0]->getSourceRange() << Range) : (PDiag(diag::err_ovl_no_viable_subscript) << Args[0]->getType() << Args[0]->getSourceRange() << Range);"},{E,15068,"/// BuildCallToObjectOfClassType - Build a call to an object of class\n/// type (C++ [over.call.object]), which can end up invoking an\n/// overloaded function call operator (@c operator()) or performing a\n/// user-defined conversion on the object argument.\nExprResult Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc) {\n  // ...\n  case OR_No_Viable_Function: {\n    PartialDiagnostic PD = CandidateSet.empty() ? (PDiag(diag::err_ovl_no_oper) << Object.get()->getType() << /*call*/ 1 << Object.get()->getSourceRange()) : (PDiag(diag::err_ovl_no_viable_object_call) << Object.get()->getType() << Object.get()->getSourceRange());"}},

[b]="err_ovl_no_viable_conversion_in_cast",

[j]={{nil,t,"no matching conversion for %select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|functional-style cast|}0 from %1 to %2"},{o,nil,"no matching conversion for %select{|static_cast|reinterpret_cast|dynamic_cast|C-style cast|functional-style cast}0 from %1 to %2"}},

[i]={{nil,t,{"no matching conversion for ",{a,xb,Nb,Qb,Mb,Sb,a}," from B to C"}},{o,nil,{"no matching conversion for ",{a,xb,Nb,Qb,Mb,Sb}," from B to C"}}},

[h]=k,

[c]="no matching conversion for (?:|static_cast|reinterpret_cast|dynamic_cast|C\\-style cast|functional\\-style cast|) from (.*?) to (.*?)",

[f]=a,

[e]=m,

[g]={"909acf820969",1297708450,"Provide overload diagnostics when explicit casts involving class types fail.","Provide overload diagnostics when explicit casts involving class types fail.\nPR8626.\n\nllvm-svn: 125506"},

[d]={{"clang/lib/Sema/SemaCast.cpp",493,"/// Try to diagnose a failed overloaded cast.  Returns true if\n/// diagnostics were emitted.\nstatic bool tryDiagnoseOverloadedCast(Sema &S, CastType CT, SourceRange range, Expr *src, QualType destType, bool listInitialization) {\n  // ...\n  case OR_No_Viable_Function:\n    if (candidates.empty())\n    // ...\n    else\n      msg = diag::err_ovl_no_viable_conversion_in_cast;"}},

[b]="err_ovl_no_viable_function_in_call",

[j]="no matching function for call to %0",

[i]="no matching function for call to A",

[h]=k,

[c]="no matching function for call to (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{O,6910,"static void checkDirectCallValidity(Sema &S, const Expr *Fn, FunctionDecl *Callee, MultiExprArg ArgExprs) {\n  // ...\n  if (const EnableIfAttr *Attr = S.CheckEnableIf(Callee, Fn->getBeginLoc(), ArgExprs, true)) {\n    S.Diag(Fn->getBeginLoc(), isa<CXXMethodDecl>(Callee) ? diag::err_ovl_no_viable_member_function_in_call : diag::err_ovl_no_viable_function_in_call) << Callee << Callee->getSourceRange();"},{Q,2604,"static bool resolveAllocationOverload(Sema &S, LookupResult &R, SourceRange Range, SmallVectorImpl<Expr *> &Args, bool &PassAlignment, FunctionDecl *&Operator, OverloadCandidateSet *AlignedCandidates, Expr *AlignArg, bool Diagnose) {\n  // ...\n  case OR_No_Viable_Function:\n    // ...\n    if (Diagnose) {\n      // ...\n      S.Diag(R.getNameLoc(), diag::err_ovl_no_viable_function_in_call) << R.getLookupName() << Range;"},{Q,3873,"static bool resolveBuiltinNewDeleteOverload(Sema &S, CallExpr *TheCall, bool IsDelete, FunctionDecl *&Operator) {\n  // ...\n  case OR_No_Viable_Function:\n    Candidates.NoteCandidates(PartialDiagnosticAt(R.getNameLoc(), S.PDiag(diag::err_ovl_no_viable_function_in_call) << R.getLookupName() << Range), S, OCD_AllCandidates, Args);"},{E,13527,"/// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns\n/// the completed call expression. If overload resolution fails, emits\n/// diagnostics and returns ExprError()\nstatic ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, OverloadCandidateSet *CandidateSet, OverloadCandidateSet::iterator *Best, OverloadingResult OverloadResult, bool AllowTypoCorrection) {\n  // ...\n  case OR_No_Viable_Function: {\n    // ...\n    CandidateSet->NoteCandidates(PartialDiagnosticAt(Fn->getBeginLoc(), SemaRef.PDiag(diag::err_ovl_no_viable_function_in_call) << ULE->getName() << Fn->getSourceRange()), SemaRef, OCD_AllCandidates, Args);"},{E,15364,"/// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to\n/// a literal operator described by the provided lookup results.\nExprResult Sema::BuildLiteralOperatorCall(LookupResult &R, DeclarationNameInfo &SuffixInfo, ArrayRef<Expr *> Args, SourceLocation LitEndLoc, TemplateArgumentListInfo *TemplateArgs) {\n  // ...\n  case OR_No_Viable_Function:\n    CandidateSet.NoteCandidates(PartialDiagnosticAt(UDSuffixLoc, PDiag(diag::err_ovl_no_viable_function_in_call) << R.getLookupName()), *this, OCD_AllCandidates, Args);"}},

[b]="err_ovl_no_viable_function_in_init",

[j]="no matching constructor for initialization of %0",

[i]="no matching constructor for initialization of A",

[h]=k,

[c]="no matching constructor for initialization of (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{P,9912,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  // ...\n  case FK_ListConstructorOverloadFailed:\n  case FK_ConstructorOverloadFailed: {\n    // ...\n    case OR_No_Viable_Function:\n      // ...\n      FailedCandidateSet.NoteCandidates(PartialDiagnosticAt(Kind.getLocation(), S.PDiag(diag::err_ovl_no_viable_function_in_init) << DestType << ArgsRange), S, OCD_AllCandidates, Args);"}},

[b]="err_ovl_no_viable_literal_operator",

[j]="no matching literal operator for call to %0%select{| with argument of type %2| with arguments of types %2 and %3}1%select{| or \'const char *\'}4%select{|, and no matching literal operator template}5",

[i]={{nil,nil,{"no matching literal operator for call to A",{a," with argument of type C"," with arguments of types C and D"},{a," or \'const char *\'"},{a,", and no matching literal operator template"}}}},

[h]=k,

[c]="no matching literal operator for call to (.*?)(?:| with argument of type (.*?)| with arguments of types (.*?) and (.*?))(?:| or \'const char \\*\')(?:|, and no matching literal operator template)",

[f]=a,

[e]=m,

[g]={"bcc22fc4e1b2",1331280036,"Support for raw and template forms of numeric user-defined literals,","Support for raw and template forms of numeric user-defined literals,\nand lots of tidying up.\n\nllvm-svn: 152392"},

[d]={{"clang/lib/Sema/SemaLookup.cpp",3781,"/// LookupLiteralOperator - Determine which literal operator should be used for\n/// a user-defined literal, per C++11 [lex.ext].\n///\n/// Normal overload resolution is not used to select which literal operator to\n/// call for a user-defined literal. Look up the provided literal operator name,\n/// and filter the results to the appropriate set for the given argument types.\nSema::LiteralOperatorLookupResult Sema::LookupLiteralOperator(Scope *S, LookupResult &R, ArrayRef<QualType> ArgTys, bool AllowRaw, bool AllowTemplate, bool AllowStringTemplatePack, bool DiagnoseMissing, StringLiteral *StringLit) {\n  // ...\n  // Didn\'t find anything we could use.\n  if (DiagnoseMissing) {\n    Diag(R.getNameLoc(), diag::err_ovl_no_viable_literal_operator) << R.getLookupName() << (int)ArgTys.size() << ArgTys[0] << (ArgTys.size() == 2 ? ArgTys[1] : QualType()) << AllowRaw << (AllowTemplate || AllowStringTemplatePack);"}},

[b]="err_ovl_no_viable_member_function_in_call",

[j]="no matching member function for call to %0",

[i]="no matching member function for call to A",

[h]=k,

[c]="no matching member function for call to (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{O,6907,"static void checkDirectCallValidity(Sema &S, const Expr *Fn, FunctionDecl *Callee, MultiExprArg ArgExprs) {\n  // ...\n  if (const EnableIfAttr *Attr = S.CheckEnableIf(Callee, Fn->getBeginLoc(), ArgExprs, true)) {\n    S.Diag(Fn->getBeginLoc(), isa<CXXMethodDecl>(Callee) ? diag::err_ovl_no_viable_member_function_in_call : diag::err_ovl_no_viable_function_in_call) << Callee << Callee->getSourceRange();"},{E,14824,"/// BuildCallToMemberFunction - Build a call to a member\n/// function. MemExpr is the expression that refers to the member\n/// function (and includes the object parameter), Args/NumArgs are the\n/// arguments to the function call (not including the object\n/// parameter). The caller needs to validate that the member\n/// expression refers to a non-static member function or an overloaded\n/// member function.\nExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n  // ...\n  if (isa<MemberExpr>(NakedMemExpr)) {\n  // ...\n  } else {\n    // ...\n    case OR_No_Viable_Function:\n      CandidateSet.NoteCandidates(PartialDiagnosticAt(UnresExpr->getMemberLoc(), PDiag(diag::err_ovl_no_viable_member_function_in_call) << DeclName << MemExprE->getSourceRange()), *this, OCD_AllCandidates, Args);"},{E,14903,"/// BuildCallToMemberFunction - Build a call to a member\n/// function. MemExpr is the expression that refers to the member\n/// function (and includes the object parameter), Args/NumArgs are the\n/// arguments to the function call (not including the object\n/// parameter). The caller needs to validate that the member\n/// expression refers to a non-static member function or an overloaded\n/// member function.\nExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc, Expr *ExecConfig, bool IsExecConfig, bool AllowRecovery) {\n  // ...\n  // In the case the method to call was not selected by the overloading\n  // resolution process, we still need to handle the enable_if attribute. Do\n  // that here, so it will not hide previous -- and more relevant -- errors.\n  if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {\n    if (const EnableIfAttr *Attr = CheckEnableIf(Method, LParenLoc, Args, true)) {\n      Diag(MemE->getMemberLoc(), diag::err_ovl_no_viable_member_function_in_call) << Method << Method->getSourceRange();"}},

[b]="err_ovl_no_viable_object_call",

[j]="no matching function for call to object of type %0",

[i]="no matching function for call to object of type A",

[h]=k,

[c]="no matching function for call to object of type (.*?)",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,15071,"/// BuildCallToObjectOfClassType - Build a call to an object of class\n/// type (C++ [over.call.object]), which can end up invoking an\n/// overloaded function call operator (@c operator()) or performing a\n/// user-defined conversion on the object argument.\nExprResult Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, SourceLocation LParenLoc, MultiExprArg Args, SourceLocation RParenLoc) {\n  // ...\n  case OR_No_Viable_Function: {\n    PartialDiagnostic PD = CandidateSet.empty() ? (PDiag(diag::err_ovl_no_oper) << Object.get()->getType() << /*call*/ 1 << Object.get()->getSourceRange()) : (PDiag(diag::err_ovl_no_viable_object_call) << Object.get()->getType() << Object.get()->getSourceRange());"}},

[b]="err_ovl_no_viable_oper",

[j]="no viable overloaded \'%0\'",

[i]="no viable overloaded \'A\'",

[h]=k,

[c]="no viable overloaded \'(.*?)\'",

[f]=a,

[e]=m,

[g]={s,1236199783,q,r},

[d]={{E,14256,"/// Create a binary operation that may resolve to an overloaded\n/// operator.\n///\n/// \\param OpLoc The location of the operator itself (e.g., \'+\').\n///\n/// \\param Opc The BinaryOperatorKind that describes this operator.\n///\n/// \\param Fns The set of non-member functions that will be\n/// considered by overload resolution. The caller needs to build this\n/// set based on the context using, e.g.,\n/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This\n/// set should not contain any member functions; those will be added\n/// by CreateOverloadedBinOp().\n///\n/// \\param LHS Left-hand argument.\n/// \\param RHS Right-hand argument.\n/// \\param PerformADL Whether to consider operator candidates found by ADL.\n/// \\param AllowRewrittenCandidates Whether to consider candidates found by\n///        C++20 operator rewrites.\n/// \\param DefaultedFn If we are synthesizing a defaulted operator function,\n///        the function in question. Such a function is never a candidate in\n///        our overload resolution. This also enables synthesizing a three-way\n///        comparison from < and == as described in C++20 [class.spaceship]p1.\nExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, BinaryOperatorKind Opc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS, bool PerformADL, bool AllowRewrittenCandidates, FunctionDecl *DefaultedFn) {\n  // ...\n  case OR_No_Viable_Function: {\n    // ...\n    if (Args[0]->getType()->isRecordType() && Opc >= BO_Assign && Opc <= BO_OrAssign) {\n      Diag(OpLoc, diag::err_ovl_no_viable_oper) << BinaryOperator::getOpcodeStr(Opc) << Args[0]->getSourceRange() << Args[1]->getSourceRange();"},{E,15282,"/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->\n///  (if one exists), where @c Base is an expression of class type and\n/// @c Member is the name of the member we\'re trying to find.\nExprResult Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, bool *NoArrowOperatorFound) {\n  // ...\n  case OR_No_Viable_Function: {\n    // ...\n    if (CandidateSet.empty()) {\n    // ...\n    } else\n      Diag(OpLoc, diag::err_ovl_no_viable_oper) << \"operator->\" << Base->getSourceRange();"}},