Module:ClangDiags/DiagsLongData6: Difference between revisions

local c="regex1";

local d="category_hist";

local e="regex2";

local g="note\\: ";

local h="message_hist";

local j="commit";

local k="source";

local m="10.0";

local n="Semantic Issue";

local o="clang/lib/AST/ExprConstant.cpp";

local p="9.0";

local q="16.0";

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

local s="12.0";

local u="7.0";

local v="8.0";

local w="15.0";

local x="13.0";

local y="5.0";

local z="6.0";

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

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

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

local D="destructor";

local E="constructor";

local F="read of";

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

local H="clang/test/SemaObjC/non-trivial-c-union.m:5:9: note: \'U0\' has subobjects that are non-trivial to destruct";

local I="clang/test/SemaObjC/non-trivial-c-union.m:6:6: note: f0 has type \'__strong id\' that is non-trivial to destruct";

local J="clang/test/SemaObjC/non-trivial-c-union.m:7:13: note: f1 has type \'__weak id\' that is non-trivial to destruct";

local K="clang/lib/AST/ASTStructuralEquivalence.cpp";

local L="method D";

local M="clang/lib/AST/Interp/Interp.cpp";

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

local O="assignment to";

local P="increment of";

local R="clang/test/SemaObjC/non-trivial-c-union.m:5:9: note: \'U0\' has subobjects that are non-trivial to copy";

local S="clang/test/SemaObjC/non-trivial-c-union.m:6:6: note: f0 has type \'__strong id\' that is non-trivial to copy";

local T="clang/test/SemaObjC/non-trivial-c-union.m:7:13: note: f1 has type \'__weak id\' that is non-trivial to copy";

local U="14.0";

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

local W="clang/lib/Sema/SemaTemplateInstantiate.cpp";

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

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

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

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

local bb="clang/lib/Driver/Driver.cpp";

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

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

local eb="typeid applied to";

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

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

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

local jb="For P0784R7: Add support for dynamic allocation with new / delete during";

local kb="member call on";

local lb="For P0784R7: Add support for dynamic allocation with new / delete during\nconstant evaluation.\n\nllvm-svn: 373036";

local mb="dynamic_cast of";

local nb="AST Deserialization Issue";

local pb="clang/test/CXX/expr/expr.const/p2-0x.cpp";

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

local sb="but in \'A\' found ";

local ub="clang/test/SemaCXX/constant-expression-cxx2a.cpp";

local vb="clang/lib/Sema/SemaConcept.cpp";

local wb="class";

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

local yb="and";

local zb="because";

local Bb="clang/test/SemaObjC/non-trivial-c-union.m:6:6: note: f0 has type \'__strong id\' that is non-trivial to default-initialize";

local Cb="clang/test/SemaObjC/non-trivial-c-union.m:5:9: note: \'U0\' has subobjects that are non-trivial to default-initialize";

local Db=" is not allowed in a constant expression";

local Fb="clang/test/SemaObjC/non-trivial-c-union.m:7:13: note: f1 has type \'__weak id\' that is non-trivial to default-initialize";

local Gb="destruction of";

local Hb="reference";

local Ib="Improve static checks for sprintf and __builtin___sprintf_chk";

local Jb="Implement P2361 Unevaluated string literals";

local Kb="Implement P2361 Unevaluated string literals\n\nThis patch proposes to handle in an uniform fashion\nthe parsing of strings that are never evaluated,\nin asm statement, static assert, attrributes, extern,\netc.\n\nUnevaluated strings are UTF-8 internally and so currently\nbehave as narrow strings, but these things will diverge with\nD93031.\n\nThe big question both for this patch and the P2361 paper\nis whether we risk breaking code by disallowing\nencoding prefixes in this context.\nI hope this patch may allow to gather some data on that.\n\nFuture work:\nImprove the rendering of unicode characters, line break\nand so forth in static-assert messages\n\nReviewed By: aaron.ballman, shafik\n\nDifferential Revision: https://reviews.llvm.org/D105759";

local Lb="When checking scopes for indirect goto, be more permissive (but still safe)\nabout the permitted scopes.  Specifically:\n  1) Permit labels and gotos to appear after a prologue of variable initializations.\n  2) Permit indirect gotos to jump out of scopes that don\'t require cleanup.\n  3) Diagnose possible attempts to indirect-jump out of scopes that do require\n     cleanup.\nThis requires a substantial reinvention of the algorithm for checking indirect\ngoto.  The current algorithm is Omega(M*N), with M = the number of unique\nscopes being jumped from and N = the number of unique scopes being jumped to,\nwith an additional factor that is probably (worst-case) linear in the depth\nof scopes. Thus the entire thing is likely cubic given some truly bizarre\nill-formed code;  on well-formed code the additional factor collapses to\nan amortized constant (when amortized over the entire function) and so\nthe algorithm is quadratic.  Even this requires every label to appear in\nits own scope, which would be very unusual for indirect-goto code (and\nextremely unlikely for well-formed code);  it is far more likely that\nall labels will be in the same scope and so the algorithm becomes linear.\nFor such a marginal feature, I am fairly happy with this result.\n\n(this is using JumpDiagnostic\'s definition of scope, where successive\nvariables in a block appear in their own scope)\n\nllvm-svn: 103536";

local Mb="61d065e21ff3";

local Nb="[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 Ob="[clang] Implement objc_non_runtime_protocol to remove protocol metadata";

local Pb="14f6bfcb52e7";

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

local Rb="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 Sb="Let clang atomic builtins fetch add/sub support floating point types";

local Tb="When checking scopes for indirect goto, be more permissive (but still safe)";

local Ub="base class";

local Vb="95f50964fbf5";

local Wb=" here";

local Xb="cf819ab38311";

local Yb="clang/lib/Sema/SemaAvailability.cpp";

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

local ac="6d485ff455ea";

local bc="Improve static checks for sprintf and __builtin___sprintf_chk\n\nImplement a pessimistic evaluator of the minimal required size for a buffer\nbased on the format string, and couple that with the fortified version to emit a\nwarning when the buffer size is lower than the lower bound computed from the\nformat string.\n\nDifferential Revision: https://reviews.llvm.org/D71566";

local cc="[c++20] Determine whether a defaulted comparison should be deleted or\nconstexpr.";

local dc="constexpr: semantic checking for constexpr functions and constructors. Based in";

local ec="[Clang] Implement P2738R1 - constexpr cast from void*";

local fc="copy";

local gc="clang/test/SemaCXX/constexpr-string.cpp";

local hc="eb3c10c248ac";

local ic="constexpr: semantic checking for constexpr functions and constructors. Based in\npart on patches by Peter Collingbourne.\n\nWe diverge from the C++11 standard in a few areas, mostly related to checking\nconstexpr function declarations, and not just definitions. See WG21 paper\nN3308=11-0078 for details.\n\nFunction invocation substitution is not available in this patch; constexpr\nfunctions cannot yet be used from within constant expressions.\n\nllvm-svn: 140926";

local jc="[c++20] Determine whether a defaulted comparison should be deleted or";

local mc="clang/lib/Lex/PPMacroExpansion.cpp";

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

local Kd="Reland [clang] Check unsupported types in expressions\n\nThis was committed as ec6c847179fd, but then reverted after a failure\nin: https://lab.llvm.org/buildbot/#/builders/84/builds/13983\n\nI was not able to reproduce the problem, but I added an extra check\nfor a NULL QualType just in case.\n\nOriginal comit message:\n\nThe patch adds missing diagnostics for cases like:\n\n  float F3 = ((__float128)F1 * (__float128)F2) / 2.0f;\n\nSema::checkDeviceDecl (renamed to checkTypeSupport) is changed to work\nwith a type without the corresponding ValueDecl. It is also refactored\nso that host diagnostics for unsupported types can be added here as\nwell.\n\nDifferential Revision: https://reviews.llvm.org/D109315";

local Nd="objc-arc: Diagnose when captured variable in block literals\nrequire destruction and there is possibility of that without\nconstruction. Thanks Johnm for review and suggestions offline.\n// rdar://9535237.\n\nllvm-svn: 134906";

["note_access_protected_restricted_noobject"]={

[b]="note_access_protected_restricted_noobject",

[h]="must name member using the type of the current context %0",

[i]="must name member using the type of the current context A",

[c]=g,

[e]="must name member using the type of the current context (.*?)",

[d]=n,

[j]={"5dadb65e0722",1333767860,"Fix several problems with protected access control:","Fix several problems with protected access control:\n  - The [class.protected] restriction is non-trivial for any instance\n    member, even if the access lacks an object (for example, if it\'s\n    a pointer-to-member constant). In this case, it is equivalent to\n    requiring the naming class to equal the context class.\n  - The [class.protected] restriction applies to accesses to constructors\n    and destructors. A protected constructor or destructor can only be\n    used to create or destroy a base subobject, as a direct result.\n  - Several places were dropping or misapplying object information.\n\nThe standard could really be much clearer about what the object type is\nsupposed to be in some of these accesses.  Usually it\'s easy enough to\nfind a reasonable answer, but still, the standard makes a very confident\nstatement about accesses to instance members only being possible in\neither pointer-to-member literals or member access expressions, which\njust completely ignores concepts like constructor and destructor\ncalls, using declarations, unevaluated field references, etc.\n\nllvm-svn: 154248"},

[k]={{"clang/lib/Sema/SemaAccess.cpp",1079,"/// Given that an entity has protected natural access, check whether\n/// access might be denied because of the protected member access\n/// restriction.\n///\n/// \\return true if a note was emitted\nstatic bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC, AccessTarget &Target) {\n  // ...\n  for (EffectiveContext::record_iterator I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {\n   // ...\n   // If we don\'t have an instance context, [class.protected] says the\n    // naming class has to equal the context class.\n    if (!Target.hasInstanceContext()) {\n      // ...\n      S.Diag(D->getLocation(), diag::note_access_protected_restricted_noobject) << S.Context.getTypeDeclType(ECRecord);"}},

["clang/test/CXX/class.access/class.protected/p1.cpp"]={"clang/test/CXX/class.access/class.protected/p1.cpp:250:10: note: must name member using the type of the current context \'test7::B\'","clang/test/CXX/class.access/class.protected/p1.cpp:250:10: note: must name member using the type of the current context \'test7::C\'","clang/test/CXX/class.access/class.protected/p1.cpp:250:10: note: must name member using the type of the current context \'test7::D\'","clang/test/CXX/class.access/class.protected/p1.cpp:288:10: note: must name member using the type of the current context \'test8::B\'","clang/test/CXX/class.access/class.protected/p1.cpp:288:10: note: must name member using the type of the current context \'test8::C\'","clang/test/CXX/class.access/class.protected/p1.cpp:288:10: note: must name member using the type of the current context \'test8::D\'","clang/test/CXX/class.access/class.protected/p1.cpp:434:29: note: must name member using the type of the current context \'test14::B\'","clang/test/CXX/class.access/class.protected/p1.cpp:436:10: note: must name member using the type of the current context \'test14::B\'","clang/test/CXX/class.access/class.protected/p1.cpp:438:29: note: must name member using the type of the current context \'test14::B\'","clang/test/CXX/class.access/class.protected/p1.cpp:441:10: note: must name member using the type of the current context \'test14::B\'","clang/test/CXX/class.access/class.protected/p1.cpp:445:10: note: must name member using the type of the current context \'test14::B\'"}

["note_access_protected_restricted_object"]={

[b]="note_access_protected_restricted_object",

[h]="can only access this member on an object of type %0",

[i]="can only access this member on an object of type A",

[c]=g,

[e]="can only access this member on an object of type (.*?)",

[d]=n,

[j]={"5dadb65e0722",1333767860,"Fix several problems with protected access control:","Fix several problems with protected access control:\n  - The [class.protected] restriction is non-trivial for any instance\n    member, even if the access lacks an object (for example, if it\'s\n    a pointer-to-member constant).  In this case, it is equivalent to\n    requiring the naming class to equal the context class.\n  - The [class.protected] restriction applies to accesses to constructors\n    and destructors.  A protected constructor or destructor can only be\n    used to create or destroy a base subobject, as a direct result.\n  - Several places were dropping or misapplying object information.\n\nThe standard could really be much clearer about what the object type is\nsupposed to be in some of these accesses.  Usually it\'s easy enough to\nfind a reasonable answer, but still, the standard makes a very confident\nstatement about accesses to instance members only being possible in\neither pointer-to-member literals or member access expressions, which\njust completely ignores concepts like constructor and destructor\ncalls, using declarations, unevaluated field references, etc.\n\nllvm-svn: 154248"},

[k]={{"clang/lib/Sema/SemaAccess.cpp",1108,"/// Given that an entity has protected natural access, check whether\n/// access might be denied because of the protected member access\n/// restriction.\n///\n/// \\return true if a note was emitted\nstatic bool TryDiagnoseProtectedAccess(Sema &S, const EffectiveContext &EC, AccessTarget &Target) {\n // ...\n for (EffectiveContext::record_iterator I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {\n   // ...\n    return S.Diag(D->getLocation(), diag::note_access_protected_restricted_object) << S.Context.getTypeDeclType(ECRecord);"}},

["clang/test/CXX/dcl.decl/dcl.decomp/p4.cpp"]={"clang/test/CXX/dcl.decl/dcl.decomp/p4.cpp:223:9: note: can only access this member on an object of type \'p0969r0::D\'"}

["note_add_deprecation_attr"]={

[b]="note_add_deprecation_attr",

[h]="add a deprecation attribute to the declaration to silence this warning",

[i]="add a deprecation attribute to the declaration to silence this warning",

[c]=g,

[e]="add a deprecation attribute to the declaration to silence this warning",

[d]=tc,

[j]={"1da888691587",1348350470,"Comment sema: warn when comment has \\deprecated but declaration does not have a","Comment sema: warn when comment has \\deprecated but declaration does not have a\ndeprecation attribute (\'deprecated\', \'availability\' or \'unavailable\').\n\nThis warning is under a separate flag, -Wdocumentation-deprecated-sync, so it\ncan be turned off easily while leaving other -Wdocumentation warnings on.\n\nllvm-svn: 164467"},

[k]={{Ac,700,"void Sema::checkDeprecatedCommand(const BlockCommandComment *Command) {\n  // ...\n  // Try to emit a fixit with a deprecation attribute.\n  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {\n    // ...\n    Diag(Loc, diag::note_add_deprecation_attr) << FixItHint::CreateInsertion(Loc, TextToInsert);"}},

["clang/test/Sema/warn-documentation-fixits.c"]={"clang/test/Sema/warn-documentation-fixits.c:7:1: note: add a deprecation attribute to the declaration to silence this warning","clang/test/Sema/warn-documentation-fixits.c:11:1: note: add a deprecation attribute to the declaration to silence this warning","clang/test/Sema/warn-documentation-fixits.c:17:1: note: add a deprecation attribute to the declaration to silence this warning","clang/test/Sema/warn-documentation-fixits.c:24:1: note: add a deprecation attribute to the declaration to silence this warning"}

["note_add_synthesize_directive"]={

[b]={{nil,y,"note_add_synthesize_directive"}},

[h]={{nil,y,"add a \'@synthesize\' directive"}},

[i]={{nil,y,"add a \'@synthesize\' directive"}},

[c]=g,

[e]="add a \'@synthesize\' directive",

[d]={{nil,y,n}},

[j]={"6c9af50cc815",1499076744,"Add a fixit for -Wobjc-protocol-property-synthesis","Add a fixit for -Wobjc-protocol-property-synthesis\n\nrdar://32132756\n\nDifferential Revision: https://reviews.llvm.org/D34886\n\nllvm-svn: 307014"},

[k]={{qb,1940,"/// Default synthesizes all properties which must be synthesized\n/// in class\'s \\@implementation.\nvoid Sema::DefaultSynthesizeProperties(Scope *S, ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl, SourceLocation AtEnd) {\n  // ...\n  for (const auto &PropEntry : PropMap) {\n    // ...\n    if (ObjCProtocolDecl *Proto = dyn_cast<ObjCProtocolDecl>(Prop->getDeclContext())) {\n      // We won\'t auto-synthesize properties declared in protocols.\n      // Suppress the warning if class\'s superclass implements property\'s\n      // getter and implements property\'s setter (if readwrite property).\n      // Or, if property is going to be implemented in its super class.\n      if (!SuperClassImplementsProperty(IDecl, Prop) && !PropInSuperClass) {\n        // ...\n        Diag(AtEnd, diag::note_add_synthesize_directive) << FixItHint::CreateInsertion(AtEnd, FixIt);"}},

["clang/test/SemaObjC/default-synthesize.m"]={"clang/test/SemaObjC/default-synthesize.m:140:1: note: add a \'@synthesize\' directive"}

["note_additional_parens_for_variable_declaration"]={

[b]="note_additional_parens_for_variable_declaration",

[h]="add a pair of parentheses to declare a variable",

[i]="add a pair of parentheses to declare a variable",

[c]=g,

[e]="add a pair of parentheses to declare a variable",

[d]=n,

[j]={"943c44045551",1343683852,"Improvements to vexing-parse warnings. Make the no-parameters case more","Improvements to vexing-parse warnings. Make the no-parameters case more\naccurate by asking the parser whether there was an ambiguity rather than trying\nto reverse-engineer it from the DeclSpec. Make the with-parameters case have\nbetter diagnostics by using semantic information to drive the warning,\nimproving the diagnostics and adding a fixit.\n\nPatch by Nikola Smiljanic. Some minor changes by me to suppress diagnostics for\ndeclarations of the form \'T (*x)(...)\', which seem to have a very high false\npositive rate, and to reduce indentation in \'warnAboutAmbiguousFunction\'.\n\nllvm-svn: 160998"},

[k]={{Y,3893,"/// Produce an appropriate diagnostic for an ambiguity between a function\n/// declarator and a C++ direct-initializer.\nstatic void warnAboutAmbiguousFunction(Sema &S, Declarator &D, DeclaratorChunk &DeclType, QualType RT) {\n  // ...\n  if (FTI.NumParams > 0) {\n    // ...\n    S.Diag(B, diag::note_additional_parens_for_variable_declaration) << FixItHint::CreateInsertion(B, \"(\") << FixItHint::CreateInsertion(E, \")\");"}},

["clang/test/SemaCXX/dcl_ambig_res.cpp"]={"clang/test/SemaCXX/dcl_ambig_res.cpp:16:7: note: add a pair of parentheses to declare a variable","clang/test/SemaCXX/dcl_ambig_res.cpp:18:8: note: add a pair of parentheses to declare a variable","clang/test/SemaCXX/dcl_ambig_res.cpp:73:9: note: add a pair of parentheses to declare a variable"}

["note_addrof_ovl_candidate_disabled_by_enable_if_attr"]={

[b]="note_addrof_ovl_candidate_disabled_by_enable_if_attr",

[h]="candidate function made ineligible by enable_if",

[i]="candidate function made ineligible by enable_if",

[c]=g,

[e]="candidate function made ineligible by enable_if",

[d]=n,

[j]={"3e3bb95b6951",1449093488,"Add the `pass_object_size` attribute to clang.","Add the `pass_object_size` attribute to clang.\n\n`pass_object_size` is our way of enabling `__builtin_object_size` to\nproduce high quality results without requiring inlining to happen\neverywhere.\n\nA link to the design doc for this attribute is available at the\nDifferential review link below.\n\nDifferential Revision: http://reviews.llvm.org/D13263\n\nllvm-svn: 254554"},

[k]={{xb,10561,"/// Returns true if we can take the address of the function.\n///\n/// \\param Complain - If true, we\'ll emit a diagnostic\n/// \\param InOverloadResolution - For the purposes of emitting a diagnostic, are\n///  we in overload resolution?\n/// \\param Loc - The location of the statement we\'re complaining about. Ignored\n///  if we\'re not complaining, or if we\'re in overload resolution.\nstatic bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD, bool Complain, bool InOverloadResolution, SourceLocation Loc) {\n  if (!isFunctionAlwaysEnabled(S.Context, FD)) {\n    if (Complain) {\n      if (InOverloadResolution)\n        S.Diag(FD->getBeginLoc(), diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);"}},

["clang/test/Sema/overloadable.c"]={"clang/test/Sema/overloadable.c:129:3: note: candidate function made ineligible by enable_if","clang/test/Sema/overloadable.c:128:3: note: candidate function made ineligible by enable_if","clang/test/Sema/overloadable.c:129:3: note: candidate function made ineligible by enable_if","clang/test/Sema/overloadable.c:128:3: note: candidate function made ineligible by enable_if"}

["note_alias_mangled_name_alternative"]={

[b]="note_alias_mangled_name_alternative",

[h]="function by that name is mangled as \"%0\"",

[i]="function by that name is mangled as \"A\"",

[c]=g,

[e]="function by that name is mangled as \"(.*?)\"",

[d]=a,

[j]={"ba6e747f9b05",1670524276,"[clang] Set ShowInSystemHeader for module-build and module-import remarks","[clang] Set ShowInSystemHeader for module-build and module-import remarks\n\nWithout this change, the use of `-Rmodule-build` and `-Rmodule-import` only\nproduces diagnostics for modules built or imported by non-system code.\n\nFor example, if a project source file requires the Foundation module to be\nbuilt, then `-Rmodule-build` will show a single diagnostic for Foundation, but\nnot in turn for any of Foundation\'s (direct or indirect) dependencies. This is\nbecause the locations of those transitive module builds are initiated from\nsystem headers, which are ignored by default. When wanting to observe module\nbuilding/importing, the system modules can represent a significant amount of\nmodule diagnostics, and I think should be shown by default when\n`-Rmodule-build` and `-Rmodule-import` are specified.\n\nI noticed some other remarks use `ShowInSystemHeader`.\n\nDifferential Revision: https://reviews.llvm.org/D139653"},

[k]={{"clang/lib/CodeGen/CodeGenModule.cpp",586,"static bool checkAliasedGlobal(DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) {\n  // ...\n  if (GV->isDeclaration()) {\n    // ...\n    // Provide a note if the given function is not found and exists as a\n    // mangled name.\n    for (const auto &[Decl, Name] : MangledDeclNames) {\n      if (const auto *ND = dyn_cast<NamedDecl>(Decl.getDecl())) {\n       if (ND->getName() == GV->getName()) {\n          Diags.Report(Location, diag::note_alias_mangled_name_alternative) << Name << FixItHint::CreateReplacement(AliasRange, (Twine(IsIFunc ? \"ifunc\" : \"alias\") + \"(\\\"\" + Name + \"\\\")\").str());"}},

["clang/test/CodeGen/attr-ifunc.cpp"]={"clang/test/CodeGen/attr-ifunc.cpp:5:30: note: function by that name is mangled as \"_Z8f1_ifuncv\"","clang/test/CodeGen/attr-ifunc.cpp:12:40: note: function by that name is mangled as \"_Z20f6_resolver_resolverv\"","clang/test/CodeGen/attr-ifunc.cpp:17:30: note: function by that name is mangled as \"_Z11f6_resolverv\""}

["note_alias_requires_mangled_name"]={

[b]="note_alias_requires_mangled_name",

[h]="the %select{function or variable|function}0 specified in an %select{alias|ifunc}1 must refer to its mangled name",

[i]={{nil,nil,{"the ",{"function or variable",Qc}," specified in an ",{"alias","ifunc"}," must refer to its mangled name"}}},

[c]=g,

[e]="the (?:function or variable|function) specified in an (?:alias|ifunc) must refer to its mangled name",

[d]=a,

[j]={"ba6e747f9b05",1670524276,"[clang] Set ShowInSystemHeader for module-build and module-import remarks","[clang] Set ShowInSystemHeader for module-build and module-import remarks\n\nWithout this change, the use of `-Rmodule-build` and `-Rmodule-import` only\nproduces diagnostics for modules built or imported by non-system code.\n\nFor example, if a project source file requires the Foundation module to be\nbuilt, then `-Rmodule-build` will show a single diagnostic for Foundation, but\nnot in turn for any of Foundation\'s (direct or indirect) dependencies. This is\nbecause the locations of those transitive module builds are initiated from\nsystem headers, which are ignored by default. When wanting to observe module\nbuilding/importing, the system modules can represent a significant amount of\nmodule diagnostics, and I think should be shown by default when\n`-Rmodule-build` and `-Rmodule-import` are specified.\n\nI noticed some other remarks use `ShowInSystemHeader`.\n\nDifferential Revision: https://reviews.llvm.org/D139653"},

[k]={{"clang/lib/CodeGen/CodeGenModule.cpp",579,"static bool checkAliasedGlobal(DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames, SourceRange AliasRange) {\n  // ...\n  if (GV->isDeclaration()) {\n    // ...\n    Diags.Report(Location, diag::note_alias_requires_mangled_name) << IsIFunc << IsIFunc;"}},

["clang/test/Sema/attr-alias-elf.c"]={"clang/test/Sema/attr-alias-elf.c:7:30: note: the function or variable specified in an alias must refer to its mangled name","clang/test/Sema/attr-alias-elf.c:10:30: note: the function or variable specified in an alias must refer to its mangled name","clang/test/Sema/attr-alias-elf.c:49:30: note: the function or variable specified in an alias must refer to its mangled name","clang/test/Sema/attr-alias-elf.c:52:30: note: the function or variable specified in an alias must refer to its mangled name","clang/test/Sema/attr-alias-elf.c:56:30: note: the function or variable specified in an alias must refer to its mangled name"}

["note_alignas_on_declaration"]={

[b]="note_alignas_on_declaration",

[h]="declared with %0 attribute here",

[i]="declared with A attribute here",

[c]=g,

[e]="declared with (.*?) attribute here",

[d]=n,

[j]={"bc8caaf05f09",1361508939,"Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of","Implement C++11 [dcl.align]p6-p8, and C11 6.7.5/7. This had to be split out of\nthe normal attribute-merging path, because we can\'t merge alignment attributes\nwithout knowing the complete set of alignment attributes which apply to a\nparticular declaration.\n\nllvm-svn: 175861"},

[k]={{C,2859,"/// Merge alignment attributes from \\p Old to \\p New, taking into account the\n/// special semantics of C11\'s _Alignas specifier and C++11\'s alignas attribute.\n///\n/// \\return \\c true if any attributes were added to \\p New.\nstatic bool mergeAlignedAttrs(Sema &S, NamedDecl *New, Decl *Old) {\n  // ...\n  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {\n    // ...\n    S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) << OldAlignasAttr;"},{C,3087,"/// checkNewAttributesAfterDef - If we already have a definition, check that\n/// there are no new attributes in this declaration.\nstatic void checkNewAttributesAfterDef(Sema &S, Decl *New, const Decl *Old) {\n  // ...\n  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    // ...\n    if (isa<C11NoReturnAttr>(NewAttribute)) {\n    // ...\n    } else if (isa<UuidAttr>(NewAttribute)) {\n    // ...\n    } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {\n      if (AA->isAlignas()) {\n        // ...\n        S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) << AA;"}},

["clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p6.cpp"]={"clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p6.cpp:19:1: note: declared with \'alignas\' attribute here","clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p6.cpp:24:1: note: declared with \'alignas\' attribute here","clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p6.cpp:28:1: note: declared with \'alignas\' attribute here","clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p6.cpp:31:8: note: declared with \'alignas\' attribute here","clang/test/CXX/dcl.dcl/dcl.attr/dcl.align/p6.cpp:44:8: note: declared with \'alignas\' attribute here"}

["note_allocated_here"]={

[b]="note_allocated_here",

[h]="allocated with \'new%select{[]|}0\' here",

[i]={{nil,nil,{"allocated with \'new",{"[]",a},"\' here"}}},

[c]=g,

[e]="allocated with \'new(?:\\[\\]|)\' here",

[d]=n,

[j]={"538ef53c139d",1431620097,"Detect uses of mismatching forms of \'new\' and \'delete\'","Detect uses of mismatching forms of \'new\' and \'delete\'\n\nEmit warning when operand to `delete` is allocated with `new[]` or\noperand to `delete[]` is allocated with `new`.\n\nReviewers: rtrieu, jordan_rose, rsmith\n\nSubscribers: majnemer, cfe-commits\n\nDifferential Revision: http://reviews.llvm.org/D4661\n\nllvm-svn: 237368"},

[k]={{hb,3541,"static void DiagnoseMismatchedNewDelete(Sema &SemaRef, SourceLocation DeleteLoc, const MismatchingNewDeleteDetector &Detector) {\n  // ...\n  for (const auto *NE : Detector.NewExprs)\n    SemaRef.Diag(NE->getExprLoc(), diag::note_allocated_here) << Detector.IsArrayForm;"}},

["clang/test/CodeGenCXX/default-arguments.cpp"]={"clang/test/CodeGenCXX/default-arguments.cpp:63:10: note: allocated with \'new[]\' here"}

["note_also_found"]={

[b]="note_also_found",

[h]="also found",

[i]="also found",

[c]=g,

[e]="also found",

[d]=a,

[j]={"e29c5cd2398c",1260474663,"Improve the diagnostic when a new declaration conflicts with a using shadow","Improve the diagnostic when a new declaration conflicts with a using shadow\ndeclaration.  Rename note_using_decl to note_using, which is possibly less confusing.\nAdd a test for non-class-scope using decl collisions and be sure to note the case\nwe can\'t diagnose yet.\n\nllvm-svn: 91057"},

[k]={{db,3645,"void Sema::DiagnoseMultipleMethodInGlobalPool(SmallVectorImpl<ObjCMethodDecl *> &Methods, Selector Sel, SourceRange R, bool receiverIdOrClass) {\n  // ...\n  if (issueDiagnostic) {\n    // ...\n   for (unsigned I = 1, N = Methods.size(); I != N; ++I) {\n     Diag(Methods[I]->getBeginLoc(), diag::note_also_found) << Methods[I]->getSourceRange();"}},

["clang/test/SemaObjC/selector-overload.m"]={"clang/test/SemaObjC/selector-overload.m:22:1: note: also found","clang/test/SemaObjC/selector-overload.m:28:1: note: also found","clang/test/SemaObjC/selector-overload.m:34:1: note: also found","clang/test/SemaObjC/selector-overload.m:40:1: note: also found"}

["note_ambig_member_ref_object_type"]={

[b]="note_ambig_member_ref_object_type",

[h]="lookup in the object type %0 refers here",

[i]="lookup in the object type A refers here",

[c]=g,

[e]="lookup in the object type (.*?) refers here",

[d]=n,

[j]={"b7bfe794129f",1251932376,"Rewrite of our handling of name lookup in C++ member access expressions, e.g.,","Rewrite of our handling of name lookup in C++ member access expressions, e.g.,\n\n  x->Base::f\n\nWe no longer try to \"enter\" the context of the type that \"x\" points\nto. Instead, we drag that object type through the parser and pass it\ninto the Sema routines that need to know how to perform lookup within\nmember access expressions.\n\nWe now implement most of the crazy name lookup rules in C++\n[basic.lookup.classref] for non-templated code, including performing\nlookup both in the context of the type referred to by the member\naccess and in the scope of the member access itself and then detecting\nambiguities when the two lookups collide (p1 and p4; p3 and p7 are\nstill TODO). This change also corrects our handling of name lookup\nwithin template arguments of template-ids inside the\nnested-name-specifier (p6; we used to look into the scope of the\nobject expression for them) and fixes PR4703.\n\nI have disabled some tests that involve member access expressions\nwhere the object expression has dependent type, because we don\'t yet\nhave the ability to describe dependent nested-name-specifiers starting\nwith an identifier.\n\nllvm-svn: 80843"},

[k]={{"clang/lib/Sema/SemaCXXScopeSpec.cpp",684,"/// Build a new nested-name-specifier for \"identifier::\", as described\n/// by ActOnCXXNestedNameSpecifier.\n///\n/// \\param S Scope in which the nested-name-specifier occurs.\n/// \\param IdInfo Parser information about an identifier in the\n///        nested-name-spec.\n/// \\param EnteringContext If true, enter the context specified by the\n///        nested-name-specifier.\n/// \\param SS Optional nested name specifier preceding the identifier.\n/// \\param ScopeLookupResult Provides the result of name lookup within the\n///        scope of the nested-name-specifier that was computed at template\n///        definition time.\n/// \\param ErrorRecoveryLookup Specifies if the method is called to improve\n///        error recovery and what kind of recovery is performed.\n/// \\param IsCorrectedToColon If not null, suggestion of replace \'::\' -> \':\'\n///        are allowed.  The bool value pointed by this parameter is set to\n///      \'true\' if the identifier is treated as if it was followed by \':\',\n///        not \'::\'.\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in\n/// that it contains an extra parameter \\p ScopeLookupResult, which provides\n/// the result of name lookup within the scope of the nested-name-specifier\n/// that was computed at template definition time.\n///\n/// If ErrorRecoveryLookup is true, then this call is used to improve error\n/// recovery.  This means that it should not emit diagnostics, it should\n/// just return true on failure.  It also means it should only return a valid\n/// scope if it *knows* that the result is correct.  It should not return in a\n/// dependent context, for example. Nor will it extend \\p SS with the scope\n/// specifier.\nbool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon, bool OnlyNamespace) {\n  // ...\n  if (AcceptSpec) {\n    if (!ObjectType.isNull() && !ObjectTypeSearchedInScope && !getLangOpts().CPlusPlus11) {\n      // ...\n      if (isAcceptableNestedNameSpecifier(OuterDecl) && OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() && (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) || !Context.hasSameType(Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)), Context.getTypeDeclType(cast<TypeDecl>(SD))))) {\n        // ...\n        Diag(SD->getLocation(), diag::note_ambig_member_ref_object_type) << ObjectType;"},{G,609,"bool Sema::LookupTemplateName(LookupResult &Found, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, RequiredTemplateKind RequiredTemplate, AssumedTemplateKind *ATK, bool AllowTypoCorrection) {\n  // ...\n  if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope && !getLangOpts().CPlusPlus11) {\n    // ...\n    if (FoundOuter.empty()) {\n    // ...\n    } else if (FoundOuter.isAmbiguous() || !FoundOuter.isSingleResult() || !(OuterTemplate = getAsTemplateNameDecl(FoundOuter.getFoundDecl()))) {\n    // ...\n    } else if (!Found.isSuppressingDiagnostics()) {\n      //  - if the name found is a class template, it must refer to the same\n      //    entity as the one found in the class of the object expression,\n      //    otherwise the program is ill-formed.\n      if (!Found.isSingleResult() || getAsTemplateNameDecl(Found.getFoundDecl())->getCanonicalDecl() != OuterTemplate->getCanonicalDecl()) {\n        // ...\n        Diag(Found.getRepresentativeDecl()->getLocation(), diag::note_ambig_member_ref_object_type) << ObjectType;"}},

["clang/test/SemaCXX/qual-id-test.cpp"]={"clang/test/SemaCXX/qual-id-test.cpp:9:16: note: lookup in the object type \'A::sub\' refers here"}

["note_ambig_member_ref_scope"]={

[b]="note_ambig_member_ref_scope",

[h]="lookup from the current scope refers here",

[i]="lookup from the current scope refers here",

[c]=g,

[e]="lookup from the current scope refers here",

[d]=n,

[j]={"b7bfe794129f",1251932376,"Rewrite of our handling of name lookup in C++ member access expressions, e.g.,","Rewrite of our handling of name lookup in C++ member access expressions, e.g.,\n\n  x->Base::f\n\nWe no longer try to \"enter\" the context of the type that \"x\" points\nto. Instead, we drag that object type through the parser and pass it\ninto the Sema routines that need to know how to perform lookup within\nmember access expressions.\n\nWe now implement most of the crazy name lookup rules in C++\n[basic.lookup.classref] for non-templated code, including performing\nlookup both in the context of the type referred to by the member\naccess and in the scope of the member access itself and then detecting\nambiguities when the two lookups collide (p1 and p4; p3 and p7 are\nstill TODO). This change also corrects our handling of name lookup\nwithin template arguments of template-ids inside the\nnested-name-specifier (p6; we used to look into the scope of the\nobject expression for them) and fixes PR4703.\n\nI have disabled some tests that involve member access expressions\nwhere the object expression has dependent type, because we don\'t yet\nhave the ability to describe dependent nested-name-specifiers starting\nwith an identifier.\n\nllvm-svn: 80843"},

[k]={{"clang/lib/Sema/SemaCXXScopeSpec.cpp",686,"/// Build a new nested-name-specifier for \"identifier::\", as described\n/// by ActOnCXXNestedNameSpecifier.\n///\n/// \\param S Scope in which the nested-name-specifier occurs.\n/// \\param IdInfo Parser information about an identifier in the\n///        nested-name-spec.\n/// \\param EnteringContext If true, enter the context specified by the\n///        nested-name-specifier.\n/// \\param SS Optional nested name specifier preceding the identifier.\n/// \\param ScopeLookupResult Provides the result of name lookup within the\n///        scope of the nested-name-specifier that was computed at template\n///        definition time.\n/// \\param ErrorRecoveryLookup Specifies if the method is called to improve\n///        error recovery and what kind of recovery is performed.\n/// \\param IsCorrectedToColon If not null, suggestion of replace \'::\' -> \':\'\n///        are allowed.  The bool value pointed by this parameter is set to\n///      \'true\' if the identifier is treated as if it was followed by \':\',\n///        not \'::\'.\n/// \\param OnlyNamespace If true, only considers namespaces in lookup.\n///\n/// This routine differs only slightly from ActOnCXXNestedNameSpecifier, in\n/// that it contains an extra parameter \\p ScopeLookupResult, which provides\n/// the result of name lookup within the scope of the nested-name-specifier\n/// that was computed at template definition time.\n///\n/// If ErrorRecoveryLookup is true, then this call is used to improve error\n/// recovery.  This means that it should not emit diagnostics, it should\n/// just return true on failure.  It also means it should only return a valid\n/// scope if it *knows* that the result is correct.  It should not return in a\n/// dependent context, for example. Nor will it extend \\p SS with the scope\n/// specifier.\nbool Sema::BuildCXXNestedNameSpecifier(Scope *S, NestedNameSpecInfo &IdInfo, bool EnteringContext, CXXScopeSpec &SS, NamedDecl *ScopeLookupResult, bool ErrorRecoveryLookup, bool *IsCorrectedToColon, bool OnlyNamespace) {\n  // ...\n  if (AcceptSpec) {\n    if (!ObjectType.isNull() && !ObjectTypeSearchedInScope && !getLangOpts().CPlusPlus11) {\n      // ...\n      if (isAcceptableNestedNameSpecifier(OuterDecl) && OuterDecl->getCanonicalDecl() != SD->getCanonicalDecl() && (!isa<TypeDecl>(OuterDecl) || !isa<TypeDecl>(SD) || !Context.hasSameType(Context.getTypeDeclType(cast<TypeDecl>(OuterDecl)), Context.getTypeDeclType(cast<TypeDecl>(SD))))) {\n        // ...\n        Diag(OuterDecl->getLocation(), diag::note_ambig_member_ref_scope);"},{G,612,"bool Sema::LookupTemplateName(LookupResult &Found, Scope *S, CXXScopeSpec &SS, QualType ObjectType, bool EnteringContext, bool &MemberOfUnknownSpecialization, RequiredTemplateKind RequiredTemplate, AssumedTemplateKind *ATK, bool AllowTypoCorrection) {\n  // ...\n  if (S && !ObjectType.isNull() && !ObjectTypeSearchedInScope && !getLangOpts().CPlusPlus11) {\n    // ...\n    if (FoundOuter.empty()) {\n    // ...\n    } else if (FoundOuter.isAmbiguous() || !FoundOuter.isSingleResult() || !(OuterTemplate = getAsTemplateNameDecl(FoundOuter.getFoundDecl()))) {\n    // ...\n    } else if (!Found.isSuppressingDiagnostics()) {\n      //  - if the name found is a class template, it must refer to the same\n      //    entity as the one found in the class of the object expression,\n      //    otherwise the program is ill-formed.\n      if (!Found.isSingleResult() || getAsTemplateNameDecl(Found.getFoundDecl())->getCanonicalDecl() != OuterTemplate->getCanonicalDecl()) {\n        // ...\n        Diag(FoundOuter.getFoundDecl()->getLocation(), diag::note_ambig_member_ref_scope);"}},

["clang/test/SemaCXX/qual-id-test.cpp"]={"clang/test/SemaCXX/qual-id-test.cpp:94:25: note: lookup from the current scope refers here"}

["note_ambiguous_atomic_constraints"]={

[b]={{nil,m,"note_ambiguous_atomic_constraints"}},

[h]={{nil,m,"similar constraint expressions not considered equivalent; constraint expressions cannot be considered equivalent unless they originate from the same concept"}},

[i]={{nil,m,"similar constraint expressions not considered equivalent; constraint expressions cannot be considered equivalent unless they originate from the same concept"}},

[c]=g,

[e]="similar constraint expressions not considered equivalent; constraint expressions cannot be considered equivalent unless they originate from the same concept",

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

[j]={"349636d2bfc3",1575555459,"Implement VectorType conditional operator GNU extension.","Implement VectorType conditional operator GNU extension.\n\nGCC supports the conditional operator on VectorTypes that acts as a\n\'select\' in C++ mode. This patch implements the support. Types are\nconverted as closely to GCC\'s behavior as possible, though in a few\nplaces consistency with our existing vector type support was preferred.\n\nNote that this implementation is different from the OpenCL version in a\nnumber of ways, so it unfortunately required a different implementation.\n\nFirst, the SEMA rules and promotion rules are significantly different.\n\nSecondly, GCC implements COND[i] != 0 ? LHS[i] : RHS[i] (where i is in\nthe range 0- VectorSize, for each element).  In OpenCL, the condition is\nCOND[i] < 0 ? LHS[i]: RHS[i].\n\nIn the process of implementing this, it was also required to make the\nexpression COND ? LHS : RHS type dependent if COND is type dependent,\nsince the type is now dependent on the condition. For example:\n\n   T ? 1 : 2;\n\nIs not typically type dependent, since the result can be deduced from\nthe operands. HOWEVER, if T is a VectorType now, it could change this\nto a \'select\' (basically a swizzle with a non-constant mask) with the 1\nand 2 being promoted to vectors themselves.\n\nWhile this is a change, it is NOT a standards incompatible change. Based\non my (and D. Gregor\'s, at the time of writing the code) reading of the\nstandard, the expression is supposed to be type dependent if ANY\nsub-expression is type dependent.\n\nDifferential Revision: https://reviews.llvm.org/D71463"},

[k]={{vb,1579,"bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2) {\n // ...\n Diag(AmbiguousAtomic1->getBeginLoc(), diag::note_ambiguous_atomic_constraints) << AmbiguousAtomic1->getSourceRange();"}},

["clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp"]={"clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp:3:32: note: similar constraint expressions not considered equivalent; constraint expressions cannot be considered equivalent unless they originate from the same concept"}

["note_ambiguous_atomic_constraints_similar_expression"]={

[b]={{nil,m,"note_ambiguous_atomic_constraints_similar_expression"}},

[h]={{nil,m,"similar constraint expression here"}},

[i]={{nil,m,"similar constraint expression here"}},

[c]=g,

[e]="similar constraint expression here",

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

[j]={"349636d2bfc3",1575555459,"Implement VectorType conditional operator GNU extension.","Implement VectorType conditional operator GNU extension.\n\nGCC supports the conditional operator on VectorTypes that acts as a\n\'select\' in C++ mode. This patch implements the support. Types are\nconverted as closely to GCC\'s behavior as possible, though in a few\nplaces consistency with our existing vector type support was preferred.\n\nNote that this implementation is different from the OpenCL version in a\nnumber of ways, so it unfortunately required a different implementation.\n\nFirst, the SEMA rules and promotion rules are significantly different.\n\nSecondly, GCC implements COND[i] != 0 ? LHS[i] : RHS[i] (where i is in\nthe range 0- VectorSize, for each element).  In OpenCL, the condition is\nCOND[i] < 0 ? LHS[i]: RHS[i].\n\nIn the process of implementing this, it was also required to make the\nexpression COND ? LHS : RHS type dependent if COND is type dependent,\nsince the type is now dependent on the condition.  For example:\n\n    T ? 1 : 2;\n\nIs not typically type dependent, since the result can be deduced from\nthe operands.  HOWEVER, if T is a VectorType now, it could change this\nto a \'select\' (basically a swizzle with a non-constant mask) with the 1\nand 2 being promoted to vectors themselves.\n\nWhile this is a change, it is NOT a standards incompatible change. Based\non my (and D. Gregor\'s, at the time of writing the code) reading of the\nstandard, the expression is supposed to be type dependent if ANY\nsub-expression is type dependent.\n\nDifferential Revision: https://reviews.llvm.org/D71463"},

[k]={{vb,1,"bool Sema::MaybeEmitAmbiguousAtomicConstraintsDiagnostic(NamedDecl *D1, ArrayRef<const Expr *> AC1, NamedDecl *D2, ArrayRef<const Expr *> AC2) {\n // ...\n Diag(AmbiguousAtomic2->getBeginLoc(), diag::note_ambiguous_atomic_constraints_similar_expression) << AmbiguousAtomic2->getSourceRange();"}},

["clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp"]={"clang/test/CXX/temp/temp.constr/temp.constr.order/var-template-partial-specializations.cpp:7:32: note: similar constraint expression here"}

["note_ambiguous_candidate"]={

[b]="note_ambiguous_candidate",

[h]="candidate found by name lookup is %q0",

[i]="candidate found by name lookup is A",

[c]=g,

[e]="candidate found by name lookup is (.*?)",

[d]=n,

[j]={"5a8987ca5113",1237025389,"Update tablegen diagnostic files to be in sync with the def files.","Update tablegen diagnostic files to be in sync with the def files.\n\nllvm-svn: 67004"},

[k]={{bd,2866,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  // ...\n  case LookupResult::AmbiguousReference: {\n    // ...\n   for (auto *D : Result)\n     Diag(D->getLocation(), diag::note_ambiguous_candidate) << D;"}},

["clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp"]={"clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp:14:10: note: candidate found by name lookup is \'B::x\'","clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp:4:10: note: candidate found by name lookup is \'A::x\'","clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp:15:9: note: candidate found by name lookup is \'B::x\'","clang/test/CXX/basic/basic.lookup/basic.lookup.qual/namespace.qual/p5.cpp:5:7: note: candidate found by name lookup is \'A::x\'"}

["note_ambiguous_inherited_constructor_using"]={

[b]="note_ambiguous_inherited_constructor_using",

[h]="inherited from base class %0 here",

[i]="inherited from base class A here",

[c]=g,

[e]="inherited from base class (.*?) here",

[d]=n,

[j]={"5179eb78210a",1467140637,"P0136R1, DR1573, DR1645, DR1715, DR1736, DR1903, DR1941, DR1959, DR1991:","P0136R1, DR1573, DR1645, DR1715, DR1736, DR1903, DR1941, DR1959, DR1991:\n\nReplace inheriting constructors implementation with new approach, voted into\nC++ last year as a DR against C++11.\n\nInstead of synthesizing a set of derived class constructors for each inherited\nbase class constructor, we make the constructors of the base class visible to\nconstructor lookup in the derived class, using the normal rules for\nusing-declarations.\n\nFor constructors, UsingShadowDecl now has a ConstructorUsingShadowDecl derived\nclass that tracks the requisite additional information. We create shadow\nconstructors (not found by name lookup) in the derived class to model the\nactual initialization, and have a new expression node,\nCXXInheritedCtorInitExpr, to model the initialization of a base class from such\na constructor. (This initialization is special because it performs real perfect\nforwarding of arguments.)\n\nIn cases where argument forwarding is not possible (for inalloca calls,\nvariadic calls, and calls with callee parameter cleanup), the shadow inheriting\nconstructor is not emitted and instead we directly emit the initialization code\ninto the caller of the inherited constructor.\n\nNote that this new model is not perfectly compatible with the old model in some\ncorner cases. In particular:\n * if B inherits a private constructor from A, and C uses that constructor to\n  construct a B, then we previously required that A befriends B and B\n  befriends C, but the new rules require A to befriend C directly, and\n * if a derived class has its own constructors (and so its implicit default\n  constructor is suppressed), it may still inherit a default constructor from\n  a base class\n\nllvm-svn: 274049"},

[k]={{r,7305,"class Sema::InheritedConstructorInfo {\n // ...\n  InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow) : S(S), UseLoc(UseLoc) {\n   // ...\n    // Find the set of such base class subobjects and check that there\'s a\n    // unique constructed subobject.\n    for (auto *D : Shadow->redecls()) {\n     // ...\n     // [class.inhctor.init]p2:\n     //  If the constructor was inherited from multiple base class subobjects\n     //  of type B, the program is ill-formed.\n     if (!ConstructedBase) {\n      // ...\n      } else if (ConstructedBase != DConstructedBase && !Shadow->isInvalidDecl()) {\n        if (!DiagnosedMultipleConstructedBases) {\n          // ...\n          S.Diag(ConstructedBaseIntroducer->getLocation(), diag::note_ambiguous_inherited_constructor_using) << ConstructedBase;"},{r,7310,"class Sema::InheritedConstructorInfo {\n  // ...\n  InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow) : S(S), UseLoc(UseLoc) {\n    // ...\n   // Find the set of such base class subobjects and check that there\'s a\n    // unique constructed subobject.\n   for (auto *D : Shadow->redecls()) {\n     // ...\n     // [class.inhctor.init]p2:\n      //  If the constructor was inherited from multiple base class subobjects\n      //  of type B, the program is ill-formed.\n      if (!ConstructedBase) {\n     // ...\n     } else if (ConstructedBase != DConstructedBase && !Shadow->isInvalidDecl()) {\n       // ...\n        S.Diag(D->getIntroducer()->getLocation(), diag::note_ambiguous_inherited_constructor_using) << DConstructedBase;"}},

["clang/test/CXX/special/class.init/class.inhctor.init/p2.cpp"]={"clang/test/CXX/special/class.init/class.inhctor.init/p2.cpp:12:15: note: inherited from base class \'C2\' here","clang/test/CXX/special/class.init/class.inhctor.init/p2.cpp:11:15: note: inherited from base class \'C1\' here"}

["note_ambiguous_member_found"]={

[b]="note_ambiguous_member_found",

[h]="member found by ambiguous name lookup",

[i]="member found by ambiguous name lookup",

[c]=g,

[e]="member found by ambiguous name lookup",

[d]=n,

[j]={"5a8987ca5113",1237025389,"Update tablegen diagnostic files to be in sync with the def files.","Update tablegen diagnostic files to be in sync with the def files.\n\nllvm-svn: 67004"},

[k]={{bd,2807,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  // ...\n  case LookupResult::AmbiguousBaseSubobjects: {\n    // ...\n   Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);"},{bd,2831,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  // ...\n  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    // ...\n   for (CXXBasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end(); Path != PathEnd; ++Path) {\n     // ...\n     if (DeclsPrinted.insert(D).second) {\n        if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))\n        // ...\n        else if (const auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))\n       // ...\n        else\n          Diag(D->getLocation(), diag::note_ambiguous_member_found);"}},

["clang/test/SemaCXX/lookup-member.cpp"]={"clang/test/SemaCXX/lookup-member.cpp:30:30: note: member found by ambiguous name lookup","clang/test/SemaCXX/lookup-member.cpp:36:30: note: member found by ambiguous name lookup"}

["note_ambiguous_member_type_found"]={

[b]={{nil,s,"note_ambiguous_member_type_found"}},

[h]={{nil,s,"member type %0 found by ambiguous name lookup"}},

[i]={{nil,s,"member type A found by ambiguous name lookup"}},

[c]=g,

[e]="member type (.*?) found by ambiguous name lookup",

[d]={{nil,s,n}},

[j]={Mb,1590001902,Sb,Rb},

[k]={{bd,2825,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  // ...\n  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    // ...\n    for (CXXBasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end(); Path != PathEnd; ++Path) {\n      // ...\n     if (DeclsPrinted.insert(D).second) {\n        if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))\n          Diag(D->getLocation(), diag::note_ambiguous_member_type_found) << TD->getUnderlyingType();"},{bd,2828,"/// Produce a diagnostic describing the ambiguity that resulted\n/// from name lookup.\n///\n/// \\param Result The result of the ambiguous lookup to be diagnosed.\nvoid Sema::DiagnoseAmbiguousLookup(LookupResult &Result) {\n  // ...\n  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    // ...\n   for (CXXBasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end(); Path != PathEnd; ++Path) {\n     // ...\n      if (DeclsPrinted.insert(D).second) {\n       if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))\n       // ...\n       else if (const auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))\n         Diag(D->getLocation(), diag::note_ambiguous_member_type_found) << Context.getTypeDeclType(TD);"}},

["clang/test/SemaCXX/member-name-lookup.cpp"]={"clang/test/SemaCXX/member-name-lookup.cpp:23:8: note: member type \'B::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:30:8: note: member type \'C::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:23:8: note: member type \'B::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:30:8: note: member type \'C::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:74:8: note: member type \'B2::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:81:8: note: member type \'C2::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:74:8: note: member type \'B2::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:81:8: note: member type \'C2::E3\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:135:10: note: member type \'HasMemberType1::type\' found by ambiguous name lookup","clang/test/SemaCXX/member-name-lookup.cpp:139:10: note: member type \'HasMemberType2::type\' found by ambiguous name lookup"}

["note_ambiguous_type_conversion"]={

[b]="note_ambiguous_type_conversion",

[h]="because of ambiguity in conversion %diff{of $ to $|between types}0,1",

[i]={{nil,nil,{"because of ambiguity in conversion ",{"of A to B","between types"}}}},

[c]=g,

[e]="because of ambiguity in conversion (?:of (.*?) to (.*?)|between types)",

[d]=n,

[j]={"574de2c5a4f0",1255369879,"If built-in operators could not be selected because of ambiguity in","If built-in operators could not be selected because of ambiguity in\nuser-defined type conversions, issue list of ambiguites in addition \nto the diagnostic. So, clang now issues the following:\n\nb.cpp:19:19: error: left hand operand to ->* must be a pointer to class compatible with the right hand operand, but is \'struct C1\'\n       int i = c1->*pmf;\n                ~~^\nb.cpp:19:19: note: because of ambiguity in conversion of \'struct C1\' to \'struct E *\'\nb.cpp:5:5: note: candidate function\n   operator E*();\n   ^\nb.cpp:11:5: note: candidate function\n   operator E*();\n    ^\n\nllvm-svn: 83862"},

[k]={{xb,11697,"static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, OverloadCandidate *Cand) {\n  for (const ImplicitConversionSequence &ICS : Cand->Conversions) {\n    // ...\n    ICS.DiagnoseAmbiguousConversion(S, OpLoc, S.PDiag(diag::note_ambiguous_type_conversion));"}},

["clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp"]={"clang/test/SemaCXX/builtin-ptrtomember-overload-1.cpp:43:19: note: because of ambiguity in conversion of \'C1\' to \'E *\'"}

["note_anonymous_namespace"]={

[b]={{nil,p,"note_anonymous_namespace"}},

[h]={{nil,p,"anonymous namespace begins here"}},

[i]={{nil,p,"anonymous namespace begins here"}},

[c]=g,

[e]="anonymous namespace begins here",

[d]={{nil,p,Ld}},

[j]={"e181de7f4fe9",1555973411,"[c++2a] Implement semantic restrictions for \'export\' declarations.","[c++2a] Implement semantic restrictions for \'export\' declarations.\n\nllvm-svn: 358932"},

[k]={{Qb,790,"/// We have parsed the start of an export declaration, including the \'{\'\n/// (if present).\nDecl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, SourceLocation LBraceLoc) {\n  // ...\n  for (const DeclContext *DC = CurContext; DC; DC = DC->getLexicalParent()) {\n    if (const auto *ND = dyn_cast<NamespaceDecl>(DC)) {\n      //   An export-declaration shall not appear directly or indirectly within\n      //   an unnamed namespace [...]\n      if (ND->isAnonymousNamespace()) {\n        // ...\n        Diag(ND->getLocation(), diag::note_anonymous_namespace);"}},

["clang/test/CXX/module/module.interface/p3.cpp"]={"clang/test/CXX/module/module.interface/p3.cpp:50:11: note: anonymous namespace begins here"}

["note_arc_bridge"]={

[b]="note_arc_bridge",

[h]="use __bridge to convert directly (no change in ownership)",

[i]="use __bridge to convert directly (no change in ownership)",

[c]=g,

[e]="use __bridge to convert directly \\(no change in ownership\\)",

[d]=Gd,

[j]={gd,1308178962,dd,jd},

[k]={{B,3933,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n // ...\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\n    // ...\n   if (CreateRule != ACC_plusOne) {\n      auto DiagB = (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);"},{B,3974,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  // Bridge from a CF type to an ARC type.\n if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\n    // ...\n    if (CreateRule != ACC_plusOne) {\n      auto DiagB = (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);"},{B,4672,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  // ...\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  // ...\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n   // ...\n    case OBC_BridgeRetained: {\n      // ...\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge) << FixItHint::CreateReplacement(BridgeKeywordLoc, \"__bridge\");"},{B,4716,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  // ...\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  // ...\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n // ...\n  } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {\n    // ...\n    case OBC_BridgeTransfer: {\n      // ...\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge) << FixItHint::CreateReplacement(BridgeKeywordLoc, \"__bridge \");"}},

["clang/test/SemaObjC/arc-cf.m"]={"clang/test/SemaObjC/arc-cf.m:18:8: note: use __bridge to convert directly (no change in ownership)"}

["note_arc_bridge_retained"]={

[b]="note_arc_bridge_retained",

[h]="use %select{__bridge_retained|CFBridgingRetain call}1 to make an ARC object available as a +1 %0",

[i]={{nil,nil,{"use ",{"__bridge_retained","CFBridgingRetain call"}," to make an ARC object available as a +1 A"}}},

[c]=g,

[e]="use (?:__bridge_retained|CFBridgingRetain call) to make an ARC object available as a \\+1 (.*?)",

[d]=Gd,

[j]={gd,1308178962,dd,jd},

[k]={{B,3986,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n // ...\n // Bridge from a CF type to an ARC type.\n if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\n   // ...\n   if (CreateRule != ACC_plusZero) {\n     auto DiagB = (CCK == Sema::CCK_OtherCast && !br) ? S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType : S.Diag(br ? castExpr->getExprLoc() : noteLoc, diag::note_arc_bridge_retained) << castType << br;"},{B,4718,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  // ...\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  // ...\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n // ...\n } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {\n   // ...\n    case OBC_BridgeTransfer: {\n     // ...\n     Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained) << T << br << FixItHint::CreateReplacement(BridgeKeywordLoc, br ? \"CFBridgingRetain \" : \"__bridge_retained\");"}},

["clang/test/ARCMT/nonobjc-to-objc-cast-2.m"]={"clang/test/ARCMT/nonobjc-to-objc-cast-2.m:41:14: note: use CFBridgingRetain call to make an ARC object available as a +1 \'void *\'","clang/test/ARCMT/nonobjc-to-objc-cast-2.m:46:23: note: use CFBridgingRetain call to make an ARC object available as a +1 \'CFStringRef\' (aka \'const struct __CFString *\')","clang/test/ARCMT/nonobjc-to-objc-cast-2.m:61:29: note: use CFBridgingRetain call to make an ARC object available as a +1 \'CFStringRef\' (aka \'const struct __CFString *\')"}

["note_arc_bridge_transfer"]={

[b]="note_arc_bridge_transfer",

[h]="use %select{__bridge_transfer|CFBridgingRelease call}1 to transfer ownership of a +1 %0 into ARC",

[i]={{nil,nil,{"use ",{"__bridge_transfer","CFBridgingRelease call"}," to transfer ownership of a +1 A into ARC"}}},

[c]=g,

[e]="use (?:__bridge_transfer|CFBridgingRelease call) to transfer ownership of a \\+1 (.*?) into ARC",

[d]=Gd,

[j]={gd,1308178962,dd,jd},

[k]={{B,3946,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n // ...\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\n    // ...\n   if (CreateRule != ACC_plusZero) {\n      auto DiagB = (CCK == Sema::CCK_OtherCast && !br) ? S.Diag(noteLoc, diag::note_arc_cstyle_bridge_transfer) << castExprType : S.Diag(br ? castExpr->getExprLoc() : noteLoc, diag::note_arc_bridge_transfer) << castExprType << br;"},{B,4674,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  // ...\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n // ...\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n    // ...\n    case OBC_BridgeRetained: {\n      // ...\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer) << FromType << br << FixItHint::CreateReplacement(BridgeKeywordLoc, br ? \"CFBridgingRelease \" : \"__bridge_transfer \");"}},

["clang/test/SemaObjC/arc-cf.m"]={"clang/test/SemaObjC/arc-cf.m:18:12: note: use CFBridgingRelease call to transfer ownership of a +1 \'CFStringRef\' (aka \'const struct __CFString *\') into ARC","clang/test/SemaObjC/arc-cf.m:19:12: note: use CFBridgingRelease call to transfer ownership of a +1 \'CFStringRef\' (aka \'const struct __CFString *\') into ARC","clang/test/SemaObjC/arc-cf.m:27:12: note: use CFBridgingRelease call to transfer ownership of a +1 \'CFStringRef\' (aka \'const struct __CFString *\') into ARC","clang/test/SemaObjC/arc-cf.m:45:12: note: use CFBridgingRelease call to transfer ownership of a +1 \'CFStringRef\' (aka \'const struct __CFString *\') into ARC","clang/test/SemaObjC/arc-cf.m:46:12: note: use CFBridgingRelease call to transfer ownership of a +1 \'CFStringRef\' (aka \'const struct __CFString *\') into ARC"}

["note_arc_cstyle_bridge"]={

[b]="note_arc_cstyle_bridge",

[h]="use __bridge with C-style cast to convert directly (no change in ownership)",

[i]="use __bridge with C-style cast to convert directly (no change in ownership)",

[c]=g,

[e]="use __bridge with C\\-style cast to convert directly \\(no change in ownership\\)",

[d]=Gd,

[j]={"ac2d082f58e6",1361496168,"objective-C arc: Diagnostic can not say to use bridge","objective-C arc: Diagnostic can not say to use bridge\ncasts with c++ named casts. Change notes to say use\nbridge with c-style cast instead. // rdar://12788838\n\nllvm-svn: 175850"},

[k]={{B,3934,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\n    // ...\n    if (CreateRule != ACC_plusOne) {\n      auto DiagB = (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);"},{B,3975,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\n    // ...\n    if (CreateRule != ACC_plusOne) {\n      auto DiagB = (CCK != Sema::CCK_OtherCast) ? S.Diag(noteLoc, diag::note_arc_bridge) : S.Diag(noteLoc, diag::note_arc_cstyle_bridge);"}},

["clang/test/SemaObjCXX/objcbridge-static-cast.mm"]={"clang/test/SemaObjCXX/objcbridge-static-cast.mm:30:21: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:56:20: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:60:20: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:63:20: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:67:20: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:70:31: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:73:31: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:77:20: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:81:31: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:89:20: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:92:19: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:95:19: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:102:21: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:105:19: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:108:19: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:111:19: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:114:19: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:121:30: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:124:30: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:127:30: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:130:30: note: use __bridge with C-style cast to convert directly (no change in ownership)","clang/test/SemaObjCXX/objcbridge-static-cast.mm:133:30: note: use __bridge with C-style cast to convert directly (no change in ownership)"}

["note_arc_cstyle_bridge_retained"]={

[b]="note_arc_cstyle_bridge_retained",

[h]="use __bridge_retained with C-style cast to make an ARC object available as a +1 %0",

[i]="use __bridge_retained with C-style cast to make an ARC object available as a +1 A",

[c]=g,

[e]="use __bridge_retained with C\\-style cast to make an ARC object available as a \\+1 (.*?)",

[d]=Gd,

[j]={"ac2d082f58e6",1361496168,"objective-C arc: Diagnostic can not say to use bridge","objective-C arc: Diagnostic can not say to use bridge\ncasts with c++ named casts. Change notes to say use\nbridge with c-style cast instead. // rdar://12788838\n\nllvm-svn: 175850"},

[k]={{B,3983,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // ...\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\n   // ...\n   if (CreateRule != ACC_plusZero) {\n      auto DiagB = (CCK == Sema::CCK_OtherCast && !br) ? S.Diag(noteLoc, diag::note_arc_cstyle_bridge_retained) << castType : S.Diag(br ? castExpr->getExprLoc() : noteLoc, diag::note_arc_bridge_retained) << castType << br;"}},