Module:ClangDiags/DiagsLongData6: Difference between revisions

[n]={{"clang/lib/Sema/SemaAccess.cpp",999,"/// 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  for (EffectiveContext::record_iterator I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {\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      S.Diag(D->getLocation(), diag::note_access_protected_restricted_noobject) << S.Context.getTypeDeclType(ECRecord);"}}

[n]={{"clang/lib/Sema/SemaAccess.cpp",1023,"/// 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  for (EffectiveContext::record_iterator I = EC.Records.begin(), E = EC.Records.end(); I != E; ++I) {\n    return S.Diag(D->getLocation(), diag::note_access_protected_restricted_object) << S.Context.getTypeDeclType(ECRecord);"}}

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

[n]={{N,1548,"/// 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  for (const auto &PropEntry : PropMap) {\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        Diag(AtEnd, diag::note_add_synthesize_directive) << FixItHint::CreateInsertion(AtEnd, FixIt);"}}

[n]={{B,3414,"/// 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  if (FTI.NumParams > 0) {\n    S.Diag(B, diag::note_additional_parens_for_variable_declaration) << FixItHint::CreateInsertion(B, \"(\") << FixItHint::CreateInsertion(E, \")\");"}}

[n]={{P,9006,"/// 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);"}}

[n]={{"clang/lib/CodeGen/CodeGenModule.cpp",522,"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  if (GV->isDeclaration()) {\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());"}}

[n]={{"clang/lib/CodeGen/CodeGenModule.cpp",516,"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  if (GV->isDeclaration()) {\n    Diags.Report(Location, diag::note_alias_requires_mangled_name) << IsIFunc << IsIFunc;"}}

[n]={{t,2586,"/// 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  if (OldAlignasAttr && !NewAlignasAttr && isAttributeTargetADefinition(New)) {\n    S.Diag(OldAlignasAttr->getLocation(), diag::note_alignas_on_declaration) << OldAlignasAttr;"},{t,2793,"/// 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  for (unsigned I = 0, E = NewAttributes.size(); I != E;) {\n    if (isa<C11NoReturnAttr>(NewAttribute)) {\n    } else if (isa<UuidAttr>(NewAttribute)) {\n    } else if (const AlignedAttr *AA = dyn_cast<AlignedAttr>(NewAttribute)) {\n      if (AA->isAlignas()) {\n        S.Diag(NewAttribute->getLocation(), diag::note_alignas_on_declaration) << AA;"}}

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

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

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

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

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

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

[n]={{zb,2626,"/// 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  case LookupResult::AmbiguousReference: {\n    for (auto *D : Result)\n      Diag(D->getLocation(), diag::note_ambiguous_candidate) << D;"}}

[n]={{q,6237,"class Sema::InheritedConstructorInfo {\n  InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow) : S(S), UseLoc(UseLoc) {\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      // [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      } else if (ConstructedBase != DConstructedBase && !Shadow->isInvalidDecl()) {\n        if (!DiagnosedMultipleConstructedBases) {\n          S.Diag(ConstructedBaseIntroducer->getLocation(), diag::note_ambiguous_inherited_constructor_using) << ConstructedBase;"},{q,6240,"class Sema::InheritedConstructorInfo {\n  InheritedConstructorInfo(Sema &S, SourceLocation UseLoc, ConstructorUsingShadowDecl *Shadow) : S(S), UseLoc(UseLoc) {\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      // [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      } else if (ConstructedBase != DConstructedBase && !Shadow->isInvalidDecl()) {\n        S.Diag(D->getIntroducer()->getLocation(), diag::note_ambiguous_inherited_constructor_using) << DConstructedBase;"}}

[n]={{zb,2572,"/// 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  case LookupResult::AmbiguousBaseSubobjects: {\n    Diag((*Found)->getLocation(), diag::note_ambiguous_member_found);"},{zb,2591,"/// 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  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    for (CXXBasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end(); Path != PathEnd; ++Path) {\n      if (DeclsPrinted.insert(D).second) {\n        if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))\n        else if (const auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))\n        else\n          Diag(D->getLocation(), diag::note_ambiguous_member_found);"}}

[n]={{zb,2587,"/// 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  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    for (CXXBasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end(); Path != PathEnd; ++Path) {\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();"},{zb,2589,"/// 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  case LookupResult::AmbiguousBaseSubobjectTypes: {\n    for (CXXBasePaths::paths_iterator Path = Paths->begin(), PathEnd = Paths->end(); Path != PathEnd; ++Path) {\n      if (DeclsPrinted.insert(D).second) {\n        if (const auto *TD = dyn_cast<TypedefNameDecl>(D->getUnderlyingDecl()))\n        else if (const auto *TD = dyn_cast<TypeDecl>(D->getUnderlyingDecl()))\n          Diag(D->getLocation(), diag::note_ambiguous_member_type_found) << Context.getTypeDeclType(TD);"}}

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

[n]={{cb,707,"/// We have parsed the start of an export declaration, including the \'{\'\n/// (if present).\nDecl *Sema::ActOnStartExportDecl(Scope *S, SourceLocation ExportLoc, SourceLocation LBraceLoc) {\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        Diag(ND->getLocation(), diag::note_anonymous_namespace);"}}

[n]={{s,3202,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\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);"},{s,3224,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\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);"},{s,3787,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n    case OBC_BridgeRetained: {\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge) << FixItHint::CreateReplacement(BridgeKeywordLoc, \"__bridge\");"},{s,3818,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n  } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {\n    case OBC_BridgeTransfer: {\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge) << FixItHint::CreateReplacement(BridgeKeywordLoc, \"__bridge \");"}}

[n]={{s,3228,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\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;"},{s,3819,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n  } else if (T->isCARCBridgableType() && FromType->isObjCARCBridgableType()) {\n    case OBC_BridgeTransfer: {\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge_retained) << T << br << FixItHint::CreateReplacement(BridgeKeywordLoc, br ? \"CFBridgingRetain \" : \"__bridge_retained\");"}}

[n]={{s,3207,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\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;"},{s,3788,"ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc, ObjCBridgeCastKind Kind, SourceLocation BridgeKeywordLoc, TypeSourceInfo *TSInfo, Expr *SubExpr) {\n  if (T->isDependentType() || SubExpr->isTypeDependent()) {\n  } else if (T->isObjCARCBridgableType() && FromType->isCARCBridgableType()) {\n    case OBC_BridgeRetained: {\n      Diag(BridgeKeywordLoc, diag::note_arc_bridge_transfer) << FromType << br << FixItHint::CreateReplacement(BridgeKeywordLoc, br ? \"CFBridgingRelease \" : \"__bridge_transfer \");"}}

[n]={{s,3202,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\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);"},{s,3224,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\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);"}}

[n]={{s,3228,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from a CF type to an ARC type.\n  if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC)) {\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;"}}

[n]={{s,3207,"static void diagnoseObjCARCConversion(Sema &S, SourceRange castRange, QualType castType, ARCConversionTypeClass castACTC, Expr *castExpr, Expr *realCast, ARCConversionTypeClass exprACTC, Sema::CheckedConversionKind CCK) {\n  // Bridge from an ARC type to a CF type.\n  if (castACTC == ACTC_retainable && isAnyRetainable(exprACTC)) {\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;"}}

[n]={{V,425,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        case UnavailableAttr::IR_ARCFieldWithOwnership:\n          diag_available_here = diag::note_arc_field_with_ownership;"}}

[n]={{V,403,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        case UnavailableAttr::IR_ARCForbiddenType:\n          diag_available_here = diag::note_arc_forbidden_type;"}}

[n]={{E,2022,"/// In ARC, check whether the conventional meanings of the two methods\n/// match.  If they don\'t, it\'s a hard error.\nstatic bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl, ObjCMethodDecl *decl) {\n  if (declFamily == OMF_None) {\n    noteID = diag::note_arc_gained_method_convention;"}}

[n]={{V,420,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        case UnavailableAttr::IR_ARCInitReturnsUnrelated:\n          diag_available_here = diag::note_arc_init_returns_unrelated;"}}

[n]={{E,2017,"/// In ARC, check whether the conventional meanings of the two methods\n/// match.  If they don\'t, it\'s a hard error.\nstatic bool checkMethodFamilyMismatch(Sema &S, ObjCMethodDecl *impl, ObjCMethodDecl *decl) {\n  unsigned noteID = diag::note_arc_lost_method_convention;"}}

[n]={{y,15632,"static void diagnoseRetainCycle(Sema &S, Expr *capturer, RetainCycleOwner &owner) {\n  S.Diag(owner.Loc, diag::note_arc_retain_cycle_owner) << owner.Indirect << owner.Range;"}}

[n]={{Z,1347,"static void diagnoseRepeatedUseOfWeak(Sema &S, const sema::FunctionScopeInfo *CurFn, const Decl *D, const ParentMap &PM) {\n  // Iterate through the sorted problems and emit warnings for each.\n  for (const auto &P : UsesByStmt) {\n    // Print all the other accesses as notes.\n    for (const auto &Use : Uses) {\n      S.Diag(Use.getUseExpr()->getBeginLoc(), diag::note_arc_weak_also_accessed_here) << Use.getUseExpr()->getSourceRange();"}}

[n]={{V,408,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        case UnavailableAttr::IR_ForbiddenWeak:\n          if (S.getLangOpts().ObjCWeakRuntime)\n            diag_available_here = diag::note_arc_weak_disabled;"}}

[n]={{V,410,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  case AR_Unavailable:\n    if (auto AL = OffendingDecl->getAttr<UnavailableAttr>()) {\n      if (AL->isImplicit() && AL->getImplicitReason()) {\n        case UnavailableAttr::IR_ForbiddenWeak:\n          if (S.getLangOpts().ObjCWeakRuntime)\n          else\n            diag_available_here = diag::note_arc_weak_no_runtime;"}}

[n]={{y,15274,"void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, const ArraySubscriptExpr *ASE, bool AllowOnePastEnd, bool IndexNegated) {\n  if (IsUnboundedArray) {\n    if (index.isUnsigned() || !index.isNegative()) {\n      if (ND)\n        DiagRuntimeBehavior(ND->getBeginLoc(), BaseExpr, PDiag(diag::note_array_declared_here) << ND);"},{y,15363,"void Sema::CheckArrayAccess(const Expr *BaseExpr, const Expr *IndexExpr, const ArraySubscriptExpr *ASE, bool AllowOnePastEnd, bool IndexNegated) {\n  if (ND)\n    DiagRuntimeBehavior(ND->getBeginLoc(), BaseExpr, PDiag(diag::note_array_declared_here) << ND);"},{r,9792,"static void DiagnoseDivisionSizeofPointerOrArray(Sema &S, Expr *LHS, Expr *RHS, SourceLocation Loc) {\n  if (LHSTy->isPointerType() && !RHSTy->isPointerType()) {\n  } else if (const auto *ArrayTy = S.Context.getAsArrayType(LHSTy)) {\n    if (const auto *DRE = dyn_cast<DeclRefExpr>(LHSArg)) {\n      if (const ValueDecl *LHSArgDecl = DRE->getDecl())\n        S.Diag(LHSArgDecl->getLocation(), diag::note_array_declared_here) << LHSArgDecl;"}}

[n]={{D,8142,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_PlainStringIntoUTF8Char:\n    S.Diag(Args.front()->getBeginLoc(), diag::note_array_init_plain_string_into_char8_t) << FixItHint::CreateInsertion(Args.front()->getBeginLoc(), \"u8\");"}}

[n]={{K,1860,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder noteExplicitConv(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { return S.Diag(Conv->getLocation(), diag::note_array_size_conversion) << ConvTy->isEnumeralType() << ConvTy; }"},{K,1864,"ExprResult Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, SourceLocation PlacementLParen, MultiExprArg PlacementArgs, SourceLocation PlacementRParen, SourceRange TypeIdParens, QualType AllocType, TypeSourceInfo *AllocTypeInfo, std::optional<Expr *> ArraySize, SourceRange DirectInitRange, Expr *Initializer) {\n  if (ArraySize && *ArraySize && !(*ArraySize)->isTypeDependent()) {\n    if (getLangOpts().CPlusPlus14) {\n    } else {\n      class SizeConvertDiagnoser : public ICEConvertDiagnoser {\n        SemaDiagnosticBuilder noteAmbiguous(Sema &S, CXXConversionDecl *Conv, QualType ConvTy) override { return S.Diag(Conv->getLocation(), diag::note_array_size_conversion) << ConvTy->isEnumeralType() << ConvTy; }"}}

[n]={{Tb,515,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  for (unsigned i = 0, e = InputConstraintInfos.size(); i != e; ++i) {\n    if (InputMatchedToOutput[TiedTo] != ~0U) {\n      targetDiag(NS->getInputExpr(InputMatchedToOutput[TiedTo])->getBeginLoc(), diag::note_asm_input_duplicate_first) << TiedTo;"}}

[n]={{Tb,468,"StmtResult Sema::ActOnGCCAsmStmt(SourceLocation AsmLoc, bool IsSimple, bool IsVolatile, unsigned NumOutputs, unsigned NumInputs, IdentifierInfo **Names, MultiExprArg constraints, MultiExprArg Exprs, Expr *asmString, MultiExprArg clobbers, unsigned NumLabels, SourceLocation RParenLoc) {\n  // Validate constraints and modifiers.\n  for (unsigned i = 0, e = Pieces.size(); i != e; ++i) {\n    if (!Context.getTargetInfo().validateConstraintModifier(Literal->getString(), Piece.getModifier(), Size, SuggestedModifier)) {\n      if (!SuggestedModifier.empty()) {\n        auto B = targetDiag(Piece.getRange().getBegin(), diag::note_asm_missing_constraint_modifier) << SuggestedModifier;"}}

[n]={{P,12078,"/// 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  case OR_No_Viable_Function: {\n    if (Args[0]->getType()->isRecordType() && Opc >= BO_Assign && Opc <= BO_OrAssign) {\n      if (Args[0]->getType()->isIncompleteType()) {\n        Diag(OpLoc, diag::note_assign_lhs_incomplete) << Args[0]->getType() << Args[0]->getSourceRange() << Args[1]->getSourceRange();"}}

[n]={{O,900,"static void diagnoseWellFormedUnsatisfiedConstraintExpr(Sema &S, Expr *SubstExpr, bool First) {\n  S.Diag(SubstExpr->getSourceRange().getBegin(), diag::note_atomic_constraint_evaluated_to_false) << (int)First << SubstExpr;"}}

[n]={{O,868,"static void diagnoseWellFormedUnsatisfiedConstraintExpr(Sema &S, Expr *SubstExpr, bool First) {\n  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(SubstExpr)) {\n    case BO_NE:\n      if (BO->getLHS()->getType()->isIntegerType() && BO->getRHS()->getType()->isIntegerType()) {\n        if (!SimplifiedLHS.Diag && !SimplifiedRHS.Diag) {\n          S.Diag(SubstExpr->getBeginLoc(), diag::note_atomic_constraint_evaluated_to_false_elaborated) << (int)First << SubstExpr << toString(SimplifiedLHS.Val.getInt(), 10) << BinaryOperator::getOpcodeStr(BO->getOpcode()) << toString(SimplifiedRHS.Val.getInt(), 10);"}}

[n]={{N,1778,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(Property->getIdentifier(), Property->getQueryKind())) {\n      if ((bool)GetterMethod ^ (bool)SetterMethod) {\n        // fixit stuff.\n        if (Property->getLParenLoc().isValid() && !(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic)) {\n          Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) << FixItHint::CreateInsertion(AfterLParen, NonatomicStr);"},{N,1782,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(Property->getIdentifier(), Property->getQueryKind())) {\n      if ((bool)GetterMethod ^ (bool)SetterMethod) {\n        // fixit stuff.\n        if (Property->getLParenLoc().isValid() && !(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic)) {\n        } else if (Property->getLParenLoc().isInvalid()) {\n          Diag(Property->getLocation(), diag::note_atomic_property_fixup_suggest) << FixItHint::CreateInsertion(startLoc, \"(nonatomic) \");"},{N,1784,"void Sema::AtomicPropertySetterGetterRules(ObjCImplDecl *IMPDecl, ObjCInterfaceDecl *IDecl) {\n  for (ObjCContainerDecl::PropertyMap::iterator I = PM.begin(), E = PM.end(); I != E; ++I) {\n    if (const ObjCPropertyImplDecl *PIDecl = IMPDecl->FindPropertyImplDecl(Property->getIdentifier(), Property->getQueryKind())) {\n      if ((bool)GetterMethod ^ (bool)SetterMethod) {\n        // fixit stuff.\n        if (Property->getLParenLoc().isValid() && !(AttributesAsWritten & ObjCPropertyAttribute::kind_atomic)) {\n        } else if (Property->getLParenLoc().isInvalid()) {\n        } else\n          Diag(MethodLoc, diag::note_atomic_property_fixup_suggest);"}}

[n]={{t,6342,"static void checkDLLAttributeRedeclaration(Sema &S, NamedDecl *OldDecl, NamedDecl *NewDecl, bool IsSpecialization, bool IsDefinition) {\n  if (OldImportAttr && !HasNewAttr && (!IsInline || (IsMicrosoftABI && IsTemplate)) && !IsStaticDataMember && !NewDecl->isLocalExternDecl() && !IsQualifiedFriend) {\n    if (IsMicrosoftABI && IsDefinition) {\n      if (IsSpecialization) {\n        S.Diag(OldImportAttr->getLocation(), diag::note_attribute);"},{t,12619,"/// FinalizeDeclaration - called by ParseDeclarationAfterDeclarator to perform\n/// any semantic actions necessary after any initializer has been attached.\nvoid Sema::FinalizeDeclaration(Decl *ThisDecl) {\n  // Imported static data members cannot be defined out-of-line.\n  if (const auto *IA = dyn_cast_or_null<DLLImportAttr>(DLLAttr)) {\n    if (VD->isStaticDataMember() && VD->isOutOfLine() && VD->isThisDeclarationADefinition()) {\n      Diag(IA->getLocation(), diag::note_attribute);"},{t,13915,"Decl *Sema::ActOnFinishFunctionBody(Decl *dcl, Stmt *Body, bool IsInstantiation) {\n  {\n    // Verify and clean out per-function state.\n    if (Body && (!FD || !FD->isDefaulted())) {\n      if (FD && FD->hasAttr<NakedAttr>()) {\n        for (const Stmt *S : Body->children()) {\n          if (!isa<AsmStmt>(S) && !isa<NullStmt>(S)) {\n            Diag(FD->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);"},{q,5670,"/// Perform propagation of DLL attributes from a derived class to a\n/// templated base class for MS compatibility.\nvoid Sema::propagateDLLAttrToBaseClassTemplate(CXXRecordDecl *Class, Attr *ClassAttr, ClassTemplateSpecializationDecl *BaseTemplateSpec, SourceLocation BaseLoc) {\n  Diag(ClassAttr->getLocation(), diag::note_attribute);"},{Tb,137,"static bool CheckNakedParmReference(Expr *E, Sema &S) {\n  while (WorkList.size()) {\n    if (isa<CXXThisExpr>(E)) {\n      S.Diag(Func->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);"},{Tb,143,"static bool CheckNakedParmReference(Expr *E, Sema &S) {\n  while (WorkList.size()) {\n    if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) {\n      if (isa<ParmVarDecl>(DRE->getDecl())) {\n        S.Diag(Func->getAttr<NakedAttr>()->getLocation(), diag::note_attribute);"},{u,8224,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n  if (TSK == TSK_ExplicitInstantiationDeclaration && !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {\n    // Check for dllexport class template instantiation declarations,\n    // except for MinGW mode.\n    for (const ParsedAttr &AL : Attr) {\n      if (AL.getKind() == ParsedAttr::AT_DLLExport) {\n        Diag(AL.getLoc(), diag::note_attribute);"},{u,8231,"// Explicit instantiation of a class template specialization\nDeclResult Sema::ActOnExplicitInstantiation(Scope *S, SourceLocation ExternLoc, SourceLocation TemplateLoc, unsigned TagSpec, SourceLocation KWLoc, const CXXScopeSpec &SS, TemplateTy TemplateD, SourceLocation TemplateNameLoc, SourceLocation LAngleLoc, ASTTemplateArgsPtr TemplateArgsIn, SourceLocation RAngleLoc, const ParsedAttributesView &Attr) {\n  if (TSK == TSK_ExplicitInstantiationDeclaration && !Context.getTargetInfo().getTriple().isWindowsGNUEnvironment()) {\n    if (auto *A = ClassTemplate->getTemplatedDecl()->getAttr<DLLExportAttr>()) {\n      Diag(A->getLocation(), diag::note_attribute);"}}

[n]={{A,808,"StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *thenStmt, SourceLocation ElseLoc, Stmt *elseStmt) {\n  if (ConstevalOrNegatedConsteval || StatementKind == IfStatementKind::Constexpr) {\n    auto DiagnoseLikelihood = [&](const Stmt *S) {\n      if (const Attr *A = Stmt::getLikelihoodAttr(S)) {\n        Diags.Report(IfLoc, diag::note_attribute_has_no_effect_on_compile_time_if_here) << ConstevalOrNegatedConsteval << SourceRange(IfLoc, (ConstevalOrNegatedConsteval ? thenStmt->getBeginLoc() : LParenLoc).getLocWithOffset(-1));"}}

[n]={{"clang/lib/CodeGen/CGStmt.cpp",904,"void CodeGenFunction::EmitWhileStmt(const WhileStmt &S, ArrayRef<const Attr *> WhileAttrs) {\n  if (EmitBoolCondBranch) {\n  } else if (const Attr *A = Stmt::getLikelihoodAttr(S.getBody())) {\n    CGM.getDiags().Report(S.getWhileLoc(), diag::note_attribute_has_no_effect_on_infinite_loop_here) << SourceRange(S.getWhileLoc(), S.getRParenLoc());"}}

[n]={{t,3372,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  if (!getLangOpts().CPlusPlus) {\n    if (OldOvl != New->hasAttr<OverloadableAttr>() && !Old->isImplicit()) {\n      if (DiagOld)\n        Diag(DiagOld->getLocation(), diag::note_attribute_overloadable_prev_overload) << OldOvl;"},{t,10359,"/// Perform semantic checking of a new function declaration.\n///\n/// Performs semantic analysis of the new function declaration\n/// NewFD. This routine performs all semantic checking that does not\n/// require the actual declarator involved in the declaration, and is\n/// used both for the declaration of functions as they are parsed\n/// (called via ActOnDeclarator) and for the declaration of functions\n/// that have been instantiated via C++ template instantiation (called\n/// via InstantiateDecl).\n///\n/// \\param IsMemberSpecialization whether this new function declaration is\n/// a member specialization (that replaces any definition provided by the\n/// previous declaration).\n///\n/// This sets NewFD->isInvalidDecl() to true if there was an error.\n///\n/// \\returns true if the function declaration is a redeclaration.\nbool Sema::CheckFunctionDeclaration(Scope *S, FunctionDecl *NewFD, LookupResult &Previous, bool IsMemberSpecialization, bool DeclIsDefn) {\n  if (Redeclaration) {\n  } else if (!getLangOpts().CPlusPlus && MayNeedOverloadableChecks && !NewFD->getAttr<OverloadableAttr>()) {\n    if (OtherUnmarkedIter != Previous.end()) {\n      Diag((*OtherUnmarkedIter)->getLocation(), diag::note_attribute_overloadable_prev_overload) << false;"}}

[n]={{N,958,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  if ((IC = dyn_cast<ObjCImplementationDecl>(ClassImpDecl))) {\n    if (Synthesize && (PIkind & ObjCPropertyAttribute::kind_readonly) && property->hasAttr<IBOutletAttr>() && !AtLoc.isValid()) {\n      if (!ReadWriteProperty) {\n        if (LocPropertyAttribute(Context, \"readonly\", property->getLParenLoc(), readonlyLoc)) {\n          Diag(property->getLocation(), diag::note_auto_readonly_iboutlet_fixup_suggest) << FixItHint::CreateReplacement(ReadonlySourceRange, \"readwrite\");"}}

[n]={{V,299,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  unsigned diag_available_here = diag::note_availability_specified_here;"},{V,305,"/// Actually emit an availability diagnostic for a reference to an unavailable\n/// decl.\n///\n/// \\param Ctx The context that the reference occurred in\n/// \\param ReferringDecl The exact declaration that was referenced.\n/// \\param OffendingDecl A related decl to \\c ReferringDecl that has an\n/// availability attribute corresponding to \\c K attached to it. Note that this\n/// may not be the same as ReferringDecl, i.e. if an EnumDecl is annotated and\n/// we refer to a member EnumConstantDecl, ReferringDecl is the EnumConstantDecl\n/// and OffendingDecl is the EnumDecl.\nstatic void DoEmitAvailabilityWarning(Sema &S, AvailabilityResult K, Decl *Ctx, const NamedDecl *ReferringDecl, const NamedDecl *OffendingDecl, StringRef Message, ArrayRef<SourceLocation> Locs, const ObjCInterfaceDecl *UnknownObjCClass, const ObjCPropertyDecl *ObjCProperty, bool ObjCPropertyAccess) {\n  // Matches diag::note_availability_specified_here."},{r,130,"/// Emit a note explaining that this function is deleted.\nvoid Sema::NoteDeletedFunction(FunctionDecl *Decl) {\n  Diag(Decl->getLocation(), diag::note_availability_specified_here) << Decl << 1;"}}

[n]={{L,357,"/// Build calls to await_ready, await_suspend, and await_resume for a co_await\n/// expression.\n/// The generated AST tries to clean up temporary objects as early as\n/// possible so that they don\'t live across suspension points if possible.\n/// Having temporary objects living across suspension points unnecessarily can\n/// lead to large frame size, and also lead to memory corruptions if the\n/// coroutine frame is destroyed after coming back from suspension. This is done\n/// by wrapping both the await_ready call and the await_suspend call with\n/// ExprWithCleanups. In the end of this function, we also need to explicitly\n/// set cleanup state so that the CoawaitExpr is also wrapped with an\n/// ExprWithCleanups to clean up the awaiter associated with the co_await\n/// expression.\nstatic ReadySuspendResumeResult buildCoawaitCalls(Sema &S, VarDecl *CoroPromise, SourceLocation Loc, Expr *E) {\n  if (!AwaitReady->getType()->isDependentType()) {\n    if (Conv.isInvalid()) {\n      S.Diag(AwaitReady->getDirectCallee()->getBeginLoc(), diag::note_await_ready_no_bool_conversion);"}}

[n]={{y,11272,"/// Check for dangerous or invalid arguments to memset().\n///\n/// This issues warnings on known problematic, dangerous or unspecified\n/// arguments to the standard \'memset\', \'memcpy\', \'memmove\', and \'memcmp\'\n/// function calls.\n///\n/// \\param Call The call expression to diagnose.\nvoid Sema::CheckMemaccessArguments(const CallExpr *Call, unsigned BId, IdentifierInfo *FnName) {\n  for (unsigned ArgIdx = 0; ArgIdx != LastArg; ++ArgIdx) {\n    DiagRuntimeBehavior(Dest->getExprLoc(), Dest, PDiag(diag::note_bad_memaccess_silence) << FixItHint::CreateInsertion(ArgRange.getBegin(), \"(void*)\"));"}}

[n]={{q,2343,"/// Check the validity of a C++ base class specifier.\n///\n/// \\returns a new CXXBaseSpecifier if well-formed, emits diagnostics\n/// and returns NULL otherwise.\nCXXBaseSpecifier *Sema::CheckBaseSpecifier(CXXRecordDecl *Class, SourceRange SpecifierRange, bool Virtual, AccessSpecifier Access, TypeSourceInfo *TInfo, SourceLocation EllipsisLoc) {\n  if ((DerivedCSA || BaseCSA) && (!BaseCSA || !DerivedCSA || BaseCSA->getName() != DerivedCSA->getName())) {\n    Diag(CXXBaseDecl->getLocation(), diag::note_base_class_specified_here) << CXXBaseDecl;"},{q,3831,"/// Handle a C++ member initializer.\nMemInitResult Sema::BuildMemInitializer(Decl *ConstructorD, Scope *S, CXXScopeSpec &SS, IdentifierInfo *MemberOrBase, ParsedType TemplateTypeTy, const DeclSpec &DS, SourceLocation IdLoc, Expr *Init, SourceLocation EllipsisLoc) {\n  if (TemplateTypeTy) {\n  } else if (DS.getTypeSpecType() == TST_decltype) {\n  } else if (DS.getTypeSpecType() == TST_decltype_auto) {\n  } else {\n    if (!TyD) {\n      if (R.empty() && BaseType.isNull() && (Corr = CorrectTypo(R.getLookupNameInfo(), R.getLookupKind(), S, &SS, CCC, CTK_ErrorRecovery, ClassDecl))) {\n        if (FieldDecl *Member = Corr.getCorrectionDeclAs<FieldDecl>()) {\n        } else if (TypeDecl *Type = Corr.getCorrectionDeclAs<TypeDecl>()) {\n          if (FindBaseInitializer(*this, ClassDecl, Context.getTypeDeclType(Type), DirectBaseSpec, VirtualBaseSpec)) {\n            Diag(BaseSpec->getBeginLoc(), diag::note_base_class_specified_here) << BaseSpec->getType() << BaseSpec->getSourceRange();"}}

[n]={{r,14479,"ExprResult Sema::BuildBuiltinOffsetOf(SourceLocation BuiltinLoc, TypeSourceInfo *TInfo, ArrayRef<OffsetOfComponent> Components, SourceLocation RParenLoc) {\n  for (const OffsetOfComponent &OC : Components) {\n    // C99 7.17p3:\n    //  (If the specified member is a bit-field, the behavior is undefined.)\n    //\n    // We diagnose this as an error.\n    if (MemberDecl->isBitField()) {\n      Diag(MemberDecl->getLocation(), diag::note_bitfield_decl);"},{D,8217,"bool InitializationSequence::Diagnose(Sema &S, const InitializedEntity &Entity, const InitializationKind &Kind, ArrayRef<Expr *> Args) {\n  case FK_NonConstLValueReferenceBindingToBitfield: {\n    if (BitField)\n      S.Diag(BitField->getLocation(), diag::note_bitfield_decl);"},{Tb,815,"StmtResult Sema::ActOnMSAsmStmt(SourceLocation AsmLoc, SourceLocation LBraceLoc, ArrayRef<Token> AsmToks, StringRef AsmString, unsigned NumOutputs, unsigned NumInputs, ArrayRef<StringRef> Constraints, ArrayRef<StringRef> Clobbers, ArrayRef<Expr *> Exprs, SourceLocation EndLoc) {\n  for (uint64_t I = 0; I < NumOutputs + NumInputs; ++I) {\n    if (E->getType()->isBitIntType()) {\n    } else if (E->refersToBitField()) {\n      Diag(BitField->getLocation(), diag::note_bitfield_decl);"}}

[n]={{Z,696,"static bool SuggestInitializationFixit(Sema &S, const VarDecl *VD) {\n  if (VariableTy->isBlockPointerType() && !VD->hasAttr<BlocksAttr>()) {\n    S.Diag(VD->getLocation(), diag::note_block_var_fixit_add_initialization) << VD->getDeclName() << FixItHint::CreateInsertion(VD->getLocation(), \"__block \");"}}

[n]={{"clang/lib/Parse/Parser.cpp",2430,"bool BalancedDelimiterTracker::diagnoseOverflow() {\n  P.Diag(P.Tok, diag::note_bracket_depth);"}}

[n]={{z,687,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::BuildingBuiltinDumpStructCall:\n      Diags.Report(Active->PointOfInstantiation, diag::note_building_builtin_dump_struct_call) << convertCallArgsToString(*this, llvm::ArrayRef(Active->CallArgs, Active->NumCallArgs));"}}

[n]={{"clang/lib/Sema/Sema.cpp",1438,"// Print notes showing how we can reach FD starting from an a priori\n// known-callable function.\nstatic void emitCallStackNotes(Sema &S, const FunctionDecl *FD) {\n  while (FnIt != S.DeviceKnownEmittedFns.end()) {\n    DiagnosticBuilder Builder(S.Diags.Report(FnIt->second.Loc, diag::note_called_by));"}}

[n]={{Z,1506,"class CalledOnceCheckReporter : public CalledOnceCheckHandler {\n  void handleDoubleCall(const ParmVarDecl *Parameter, const Expr *Call, const Expr *PrevCall, bool IsCompletionHandler, bool Poised) override {\n    S.Diag(PrevCall->getBeginLoc(), diag::note_called_once_gets_called_twice) << Poised;"}}

[n]={{r,5608,"/// ConvertArgumentsForCall - Converts the arguments specified in\n/// Args/NumArgs to the parameter types of the function FDecl with\n/// function prototype Proto. Call is the call expression itself, and\n/// Fn is the function expression. For a C++ member function, this\n/// routine does not attempt to convert the object argument. Returns\n/// true if the call is ill-formed.\nbool Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef<Expr *> Args, SourceLocation RParenLoc, bool IsExecConfig) {\n  // If too few arguments are available (and we don\'t have default\n  // arguments for the remaining parameters), don\'t make the call.\n  if (Args.size() < NumParams) {\n    if (Args.size() < MinArgs) {\n      // Emit the location of the prototype.\n      if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)\n        Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl << FDecl->getParametersSourceRange();"},{r,5632,"/// ConvertArgumentsForCall - Converts the arguments specified in\n/// Args/NumArgs to the parameter types of the function FDecl with\n/// function prototype Proto. Call is the call expression itself, and\n/// Fn is the function expression. For a C++ member function, this\n/// routine does not attempt to convert the object argument. Returns\n/// true if the call is ill-formed.\nbool Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, FunctionDecl *FDecl, const FunctionProtoType *Proto, ArrayRef<Expr *> Args, SourceLocation RParenLoc, bool IsExecConfig) {\n  // If too many are passed and not variadic, error on the extras and drop\n  // them.\n  if (Args.size() > NumParams) {\n    if (!Proto->isVariadic()) {\n      // Emit the location of the prototype.\n      if (!TC && FDecl && !FDecl->getBuiltinID() && !IsExecConfig)\n        Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl << FDecl->getParametersSourceRange();"},{r,6338,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy.  The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n  // Interrupt handlers don\'t save off the VFP regs automatically on ARM,\n  // so there\'s some risk when calling out to non-interrupt handler functions\n  // that the callee might not preserve them. This is easy to diagnose here,\n  // but can be very challenging to debug.\n  // Likewise, X86 interrupt handlers may only call routines with attribute\n  // no_caller_saved_registers since there is no efficient way to\n  // save and restore the non-GPR state.\n  if (auto *Caller = getCurFunctionDecl()) {\n    if (Caller->hasAttr<ARMInterruptAttr>()) {\n      if (VFP && (!FDecl || !FDecl->hasAttr<ARMInterruptAttr>())) {\n        if (FDecl)\n          Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl;"},{r,6344,"/// BuildResolvedCallExpr - Build a call to a resolved expression,\n/// i.e. an expression not of \\p OverloadTy.  The expression should\n/// unary-convert to an expression of function-pointer or\n/// block-pointer type.\n///\n/// \\param NDecl the declaration being called, if available\nExprResult Sema::BuildResolvedCallExpr(Expr *Fn, NamedDecl *NDecl, SourceLocation LParenLoc, ArrayRef<Expr *> Args, SourceLocation RParenLoc, Expr *Config, bool IsExecConfig, ADLCallKind UsesADL) {\n  // Interrupt handlers don\'t save off the VFP regs automatically on ARM,\n  // so there\'s some risk when calling out to non-interrupt handler functions\n  // that the callee might not preserve them. This is easy to diagnose here,\n  // but can be very challenging to debug.\n  // Likewise, X86 interrupt handlers may only call routines with attribute\n  // no_caller_saved_registers since there is no efficient way to\n  // save and restore the non-GPR state.\n  if (auto *Caller = getCurFunctionDecl()) {\n    if (Caller->hasAttr<AnyX86InterruptAttr>() && ((!FDecl || !FDecl->hasAttr<AnyX86NoCallerSavedRegistersAttr>()))) {\n      if (FDecl)\n        Diag(FDecl->getLocation(), diag::note_callee_decl) << FDecl;"},{N,1243,"/// ActOnPropertyImplDecl - This routine performs semantic checks and\n/// builds the AST node for a property implementation declaration; declared\n/// as \\@synthesize or \\@dynamic.\n///\nDecl *Sema::ActOnPropertyImplDecl(Scope *S, SourceLocation AtLoc, SourceLocation PropertyLoc, bool Synthesize, IdentifierInfo *PropertyId, IdentifierInfo *PropertyIvar, SourceLocation PropertyIvarLoc, ObjCPropertyQueryKind QueryKind) {\n  if (ObjCMethodDecl *setterMethod = property->getSetterMethodDecl()) {\n    if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr && Ivar->getType()->isRecordType()) {\n      if (property->getPropertyAttributes() & ObjCPropertyAttribute::kind_atomic) {\n        if (const CXXOperatorCallExpr *CXXCE = dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))\n          if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee())\n            if (!FuncDecl->isTrivial())\n              if (property->getType()->isReferenceType()) {\n                Diag(FuncDecl->getBeginLoc(), diag::note_callee_decl) << FuncDecl;"},{"clang/lib/Sema/SemaTemplateDeduction.cpp",4263,"bool Sema::DeduceReturnType(FunctionDecl *FD, SourceLocation Loc, bool Diagnose) {\n  if (StillUndeduced && Diagnose && !FD->isInvalidDecl()) {\n    Diag(FD->getLocation(), diag::note_callee_decl) << FD;"}}

[n]={{r,5745,"static void DiagnoseCalleeStaticArrayParam(Sema &S, ParmVarDecl *PVD) {\n  if (ArrayTypeLoc ATL = TL.getAs<ArrayTypeLoc>())\n    S.Diag(PVD->getLocation(), diag::note_callee_static_array) << ATL.getLocalSourceRange();"}}

[n]={{q,8815,"void Sema::checkIllFormedTrivialABIStruct(CXXRecordDecl &RD) {\n  auto PrintDiagAndRemoveAttr = [&](unsigned N) {\n    // No diagnostics if this is a template instantiation.\n    if (!isTemplateInstantiation(RD.getTemplateSpecializationKind())) {\n      Diag(RD.getAttr<TrivialABIAttr>()->getLocation(), diag::note_cannot_use_trivial_abi_reason) << &RD << N;"}}

[n]={{t,3021,"/// mergeParamDeclAttributes - Copy attributes from the old parameter\n/// to the new one.\nstatic void mergeParamDeclAttributes(ParmVarDecl *newDecl, const ParmVarDecl *oldDecl, Sema &S) {\n  if (CDA && !oldDecl->hasAttr<CarriesDependencyAttr>()) {\n    S.Diag(FirstVD->getLocation(), diag::note_carries_dependency_missing_first_decl) << 1 /*Param*/;"},{t,3637,"/// MergeFunctionDecl - We just parsed a function \'New\' from\n/// declarator D which has the same name and scope as a previous\n/// declaration \'Old\'.  Figure out how to resolve this situation,\n/// merging decls or emitting diagnostics as appropriate.\n///\n/// In C++, New and Old must be declarations that are not\n/// overloaded. Use IsOverload to determine whether New and Old are\n/// overloaded, and to select the Old declaration that New should be\n/// merged with.\n///\n/// Returns true if there was an error, false otherwise.\nbool Sema::MergeFunctionDecl(FunctionDecl *New, NamedDecl *&OldD, Scope *S, bool MergeTypeWithOld, bool NewDeclIsDefn) {\n  if (getLangOpts().CPlusPlus) {\n    if (CDA && !Old->hasAttr<CarriesDependencyAttr>()) {\n      Diag(Old->getFirstDecl()->getLocation(), diag::note_carries_dependency_missing_first_decl) << 0 /*Function*/;"}}

[n]={{y,13555,"/// Data recursive variant of AnalyzeImplicitConversions. Subexpressions\n/// that should be visited are added to WorkList.\nstatic void AnalyzeImplicitConversions(Sema &S, AnalyzeImplicitConversionsWorkItem Item, llvm::SmallVectorImpl<AnalyzeImplicitConversionsWorkItem> &WorkList) {\n  if (const auto *BO = dyn_cast<BinaryOperator>(SourceExpr))\n    if ((BO->getOpcode() == BO_And || BO->getOpcode() == BO_Or) && BO->getLHS()->isKnownToHaveBooleanValue() && BO->getRHS()->isKnownToHaveBooleanValue() && BO->getLHS()->HasSideEffects(S.Context) && BO->getRHS()->HasSideEffects(S.Context)) {\n      S.Diag(BO->getBeginLoc(), diag::note_cast_operand_to_int);"}}

[n]={{r,12611,"// Look for instances where it is likely the comma operator is confused with\n// another operator.  There is an explicit list of acceptable expressions for\n// the left hand side of the comma operator, otherwise emit a warning.\nvoid Sema::DiagnoseCommaOperator(const Expr *LHS, SourceLocation Loc) {\n  Diag(LHS->getBeginLoc(), diag::note_cast_to_void) << LHS->getSourceRange() << FixItHint::CreateInsertion(LHS->getBeginLoc(), LangOpts.CPlusPlus ? \"static_cast<void>(\" : \"(void)(\") << FixItHint::CreateInsertion(PP.getLocForEndOfToken(LHS->getEndLoc()), \")\");"}}

[n]={{E,124,"/// Produce additional diagnostics if a category conforms to a protocol that\n/// defines a method taking a non-escaping parameter.\nstatic void diagnoseNoescape(const ParmVarDecl *NewD, const ParmVarDecl *OldD, const ObjCCategoryDecl *CD, const ObjCProtocolDecl *PD, Sema &S) {\n  if (!diagnoseNoescape(NewD, OldD, S))\n    S.Diag(CD->getLocation(), diag::note_cat_conform_to_noescape_prot) << CD->IsClassExtension() << PD << cast<ObjCMethodDecl>(NewD->getDeclContext());"}}

[n]={{bc,599,"#endif\n  // The first parse on original arguments succeeded, but second parse of\n  // generated arguments failed. Something must be wrong with the generator.\n  if (!Success2) {\n    Diags.Report(diag::note_cc1_round_trip_generated) << 1 << SerializeArgs(GeneratedArgs);"},{bc,620,"#endif\n  // If we generated different arguments from what we assume are two\n  // semantically equivalent CompilerInvocations, the Generate function may\n  // be non-deterministic.\n  if (!Equal(GeneratedArgs, ComparisonArgs)) {\n    Diags.Report(diag::note_cc1_round_trip_generated) << 1 << SerializeArgs(GeneratedArgs);"},{bc,621,"#endif\n  // If we generated different arguments from what we assume are two\n  // semantically equivalent CompilerInvocations, the Generate function may\n  // be non-deterministic.\n  if (!Equal(GeneratedArgs, ComparisonArgs)) {\n    Diags.Report(diag::note_cc1_round_trip_generated) << 2 << SerializeArgs(ComparisonArgs);"}}

[n]={{bc,574,"#endif\n  // Run the first parse on the original arguments with the dummy invocation and\n  // diagnostics.\n  if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) || DummyDiags.getNumWarnings() != 0) {\n    Diags.Report(diag::note_cc1_round_trip_original) << SerializeArgs(CommandLineArgs);"}}

[n]={{y,12605,"/// Analyzes an attempt to assign the given value to a bitfield.\n///\n/// Returns true if there was something fishy about the attempt.\nstatic bool AnalyzeBitFieldAssignment(Sema &S, FieldDecl *Bitfield, Expr *Init, SourceLocation InitLoc) {\n  if (!OriginalInit->EvaluateAsInt(Result, S.Context, Expr::SE_AllowSideEffects)) {\n    // The RHS is not constant.  If the RHS has an enum type, make sure the\n    // bitfield is wide enough to hold all the values of the enum without\n    // truncation.\n    if (const auto *EnumTy = OriginalInit->getType()->getAs<EnumType>()) {\n      if (DiagID) {\n        S.Diag(Bitfield->getTypeSpecStartLoc(), diag::note_change_bitfield_sign) << SignedEnum << TypeRange;"}}

[n]={{"clang/lib/Sema/SemaCast.cpp",1880,"/// Diagnose casts that change the calling convention of a pointer to a function\n/// defined in the current TU.\nstatic void DiagnoseCallingConvCast(Sema &Self, const ExprResult &SrcExpr, QualType DstType, SourceRange OpRange) {\n  Self.Diag(NameLoc, diag::note_change_calling_conv_fixit) << FD << DstCCName << FixItHint::CreateInsertion(NameLoc, CCAttrText);"}}

[n]={{z,709,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::ConstraintsCheck: {\n      if (isa<ConceptDecl>(Active->Entity))\n      else if (isa<TemplateDecl>(Active->Entity))\n      else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))\n      else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))\n        DiagID = diag::note_checking_constraints_for_class_spec_id_here;"}}

[n]={{z,712,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::ConstraintsCheck: {\n      if (isa<ConceptDecl>(Active->Entity))\n      else if (isa<TemplateDecl>(Active->Entity))\n      else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))\n      else if (isa<ClassTemplatePartialSpecializationDecl>(Active->Entity))\n      else {\n        DiagID = diag::note_checking_constraints_for_function_here;"}}

[n]={{z,705,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::ConstraintsCheck: {\n      if (isa<ConceptDecl>(Active->Entity))\n      else if (isa<TemplateDecl>(Active->Entity))\n        DiagID = diag::note_checking_constraints_for_template_id_here;"}}

[n]={{z,707,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::ConstraintsCheck: {\n      if (isa<ConceptDecl>(Active->Entity))\n      else if (isa<TemplateDecl>(Active->Entity))\n      else if (isa<VarTemplatePartialSpecializationDecl>(Active->Entity))\n        DiagID = diag::note_checking_constraints_for_var_spec_id_here;"}}

[n]={{E,3423,"// Note: For class/category implementations, allMethods is always null.\nDecl *Sema::ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef<Decl *> allMethods, ArrayRef<DeclGroupPtrTy> allTUVars) {\n  if (ObjCImplementationDecl *IC = dyn_cast<ObjCImplementationDecl>(ClassDecl)) {\n    if (ObjCInterfaceDecl *IDecl = IC->getClassInterface()) {\n      if (const ObjCInterfaceDecl *Super = IDecl->getSuperClass()) {\n        // An interface can subclass another interface with a\n        // objc_subclassing_restricted attribute when it has that attribute as\n        // well (because of interfaces imported from Swift). Therefore we have\n        // to check if we can subclass in the implementation as well.\n        if (IDecl->hasAttr<ObjCSubclassingRestrictedAttr>() && Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {\n          Diag(Super->getLocation(), diag::note_class_declared);"},{E,3452,"// Note: For class/category implementations, allMethods is always null.\nDecl *Sema::ActOnAtEnd(Scope *S, SourceRange AtEnd, ArrayRef<Decl *> allMethods, ArrayRef<DeclGroupPtrTy> allTUVars) {\n  if (ObjCImplementationDecl *IC = dyn_cast<ObjCImplementationDecl>(ClassDecl)) {\n  } else if (ObjCCategoryImplDecl *CatImplClass = dyn_cast<ObjCCategoryImplDecl>(ClassDecl)) {\n  } else if (const auto *IntfDecl = dyn_cast<ObjCInterfaceDecl>(ClassDecl)) {\n    if (const ObjCInterfaceDecl *Super = IntfDecl->getSuperClass()) {\n      if (!IntfDecl->hasAttr<ObjCSubclassingRestrictedAttr>() && Super->hasAttr<ObjCSubclassingRestrictedAttr>()) {\n        Diag(Super->getLocation(), diag::note_class_declared);"},{B,6246,"/// handleObjCOwnershipTypeAttr - Process an objc_ownership\n/// attribute on the specified type.\n///\n/// Returns \'true\' if the attribute was handled.\nstatic bool handleObjCOwnershipTypeAttr(TypeProcessingState &state, ParsedAttr &attr, QualType &type) {\n  // Forbid __weak for class objects marked as\n  // objc_arc_weak_reference_unavailable\n  if (lifetime == Qualifiers::OCL_Weak) {\n    if (const ObjCObjectPointerType *ObjT = type->getAs<ObjCObjectPointerType>()) {\n      if (ObjCInterfaceDecl *Class = ObjT->getInterfaceDecl()) {\n        if (Class->isArcWeakrefUnavailable()) {\n          S.Diag(ObjT->getInterfaceDecl()->getLocation(), diag::note_class_declared);"}}

[n]={{N,1831,"void Sema::DiagnoseOwningPropertyGetterSynthesis(const ObjCImplementationDecl *D) {\n  for (const auto *PID : D->property_impls()) {\n    if (PD && !PD->hasAttr<NSReturnsNotRetainedAttr>() && !PD->isClassProperty()) {\n      if (family == OMF_alloc || family == OMF_copy || family == OMF_mutableCopy || family == OMF_new) {\n        auto noteDiag = Diag(noteLoc, diag::note_cocoa_naming_declare_family) << method->getDeclName() << spelling;"}}

[n]={{C,7639,"/// Called on a for stmt to check itself and nested loops (if any).\n/// \\return Returns 0 if one of the collapsed stmts is not canonical for loop,\n/// number of collapsed loops otherwise.\nstatic unsigned checkOpenMPLoop(OpenMPDirectiveKind DKind, Expr *CollapseLoopCountExpr, Expr *OrderedLoopCountExpr, Stmt *AStmt, Sema &SemaRef, DSAStackTy &DSA, Sema::VarsWithInheritedDSAType &VarsWithImplicitDSA, OMPLoopBasedDirective::HelperExprs &Built) {\n  if (OrderedLoopCountExpr) {\n    if (!OrderedLoopCountExpr->isValueDependent() && OrderedLoopCountExpr->EvaluateAsInt(EVResult, SemaRef.getASTContext())) {\n      if (Result.getLimitedValue() < NestedLoopCount) {\n        SemaRef.Diag(CollapseLoopCountExpr->getExprLoc(), diag::note_collapse_loop_count) << CollapseLoopCountExpr->getSourceRange();"}}

[n]={{z,669,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::DefiningSynthesizedFunction: {\n      if (DFK.isSpecialMember()) {\n      } else if (DFK.isComparison()) {\n        Diags.Report(Active->PointOfInstantiation, diag::note_comparison_synthesized_at) << (int)DFK.asComparison() << RecordType;"}}

[n]={{r,1542,"ExprResult Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef<TypeSourceInfo *> Types, ArrayRef<Expr *> Exprs) {\n  for (unsigned i = 0; i < NumAssocs; ++i) {\n    if (Types[i]) {\n      if (Types[i]->getType()->isDependentType()) {\n      } else {\n        // C11 6.5.1.1p2 \"No two generic associations in the same generic\n        // selection shall specify compatible types.\"\n        for (unsigned j = i + 1; j < NumAssocs; ++j)\n          if (Types[j] && !Types[j]->getType()->isDependentType() && Context.typesAreCompatible(Types[i]->getType(), Types[j]->getType())) {\n            Diag(Types[i]->getTypeLoc().getBeginLoc(), diag::note_compat_assoc) << Types[i]->getTypeLoc().getSourceRange() << Types[i]->getType();"},{r,1593,"ExprResult Sema::CreateGenericSelectionExpr(SourceLocation KeyLoc, SourceLocation DefaultLoc, SourceLocation RParenLoc, bool PredicateIsExpr, void *ControllingExprOrType, ArrayRef<TypeSourceInfo *> Types, ArrayRef<Expr *> Exprs) {\n  // C11 6.5.1.1p2 \"The controlling expression of a generic selection shall have\n  // type compatible with at most one of the types named in its generic\n  // association list.\"\n  if (CompatIndices.size() > 1) {\n    for (unsigned I : CompatIndices) {\n      Diag(Types[I]->getTypeLoc().getBeginLoc(), diag::note_compat_assoc) << Types[I]->getTypeLoc().getSourceRange() << Types[I]->getType();"}}

[n]={{"clang/lib/Parse/Parser.cpp",215,"void Parser::checkCompoundToken(SourceLocation FirstTokLoc, tok::TokenKind FirstTokKind, CompoundToken Op) {\n  // If either token is in a macro, we expect both tokens to come from the same\n  // macro expansion.\n  if ((FirstTokLoc.isMacroID() || SecondTokLoc.isMacroID()) && PP.getSourceManager().getFileID(FirstTokLoc) != PP.getSourceManager().getFileID(SecondTokLoc)) {\n    Diag(SecondTokLoc, diag::note_compound_token_split_second_token_here) << (FirstTokKind == Tok.getKind()) << Tok.getKind() << SourceRange(SecondTokLoc);"}}

[n]={{t,12365,"void Sema::CheckCompleteVariableDeclaration(VarDecl *var) {\n  if (!var->getType()->isStructureType() && var->hasInit() && isa<InitListExpr>(var->getInit())) {\n    if (NumInits > 2)\n      for (unsigned I = 0; I < NumInits; ++I) {\n        // Diagnose missing comma in string array initialization.\n        // Do not warn when all the elements in the initializer are concatenated\n        // together. Do not warn for macros too.\n        if (NumConcat == 2 && !SL->getBeginLoc().isMacroID()) {\n          if (OnlyOneMissingComma) {\n            Diag(SL->getBeginLoc(), diag::note_concatenated_string_literal_silence);"}}

[n]={{O,881,"static void diagnoseWellFormedUnsatisfiedConstraintExpr(Sema &S, Expr *SubstExpr, bool First) {\n  if (BinaryOperator *BO = dyn_cast<BinaryOperator>(SubstExpr)) {\n  } else if (auto *CSE = dyn_cast<ConceptSpecializationExpr>(SubstExpr)) {\n    if (CSE->getTemplateArgsAsWritten()->NumTemplateArgs == 1) {\n    } else {\n      S.Diag(SubstExpr->getSourceRange().getBegin(), diag::note_concept_specialization_constraint_evaluated_to_false) << (int)First << CSE;"}}

[n]={{z,703,"/// Prints the current instantiation stack through a series of\n/// notes.\nvoid Sema::PrintInstantiationStack() {\n  for (SmallVectorImpl<CodeSynthesisContext>::reverse_iterator Active = CodeSynthesisContexts.rbegin(), ActiveEnd = CodeSynthesisContexts.rend(); Active != ActiveEnd; ++Active, ++InstantiationIdx) {\n    case CodeSynthesisContext::ConstraintsCheck: {\n      if (isa<ConceptDecl>(Active->Entity))\n        DiagID = diag::note_concept_specialization_here;"}}

[n]={{r,18141,"// Diagnose the s/=/==/ and s/\\|=/!=/ typos. Note that adding parentheses\n// will prevent this condition from triggering, which is what we want.\nvoid Sema::DiagnoseAssignmentAsCondition(Expr *E) {\n  Diag(Loc, diag::note_condition_assign_silence) << FixItHint::CreateInsertion(Open, \"(\") << FixItHint::CreateInsertion(Close, \")\");"}}

[n]={{r,18146,"// Diagnose the s/=/==/ and s/\\|=/!=/ typos. Note that adding parentheses\n// will prevent this condition from triggering, which is what we want.\nvoid Sema::DiagnoseAssignmentAsCondition(Expr *E) {\n  if (IsOrAssign)\n  else\n    Diag(Loc, diag::note_condition_assign_to_comparison) << FixItHint::CreateReplacement(Loc, \"==\");"}}

[n]={{r,18144,"// Diagnose the s/=/==/ and s/\\|=/!=/ typos. Note that adding parentheses\n// will prevent this condition from triggering, which is what we want.\nvoid Sema::DiagnoseAssignmentAsCondition(Expr *E) {\n  if (IsOrAssign)\n    Diag(Loc, diag::note_condition_or_assign_to_comparison) << FixItHint::CreateReplacement(Loc, \"!=\");"}}

[n]={{I,247,"/// Diagnose mutually exclusive attributes when present on a given\n/// declaration. Returns true if diagnosed.\ntemplate <typename AttrTy> static bool checkAttrMutualExclusion(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (const auto *A = D->getAttr<AttrTy>()) {\n    S.Diag(A->getLocation(), diag::note_conflicting_attribute);"},{I,256,"template <typename AttrTy> static bool checkAttrMutualExclusion(Sema &S, Decl *D, const Attr &AL) {\n  if (const auto *A = D->getAttr<AttrTy>()) {\n    S.Diag(A->getLocation(), diag::note_conflicting_attribute);"},{I,1857,"static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Ensure we don\'t combine these with themselves, since that causes some\n  // confusing behavior.\n  if (AL.getParsedKind() == ParsedAttr::AT_CPUDispatch) {\n    if (const auto *Other = D->getAttr<CPUDispatchAttr>()) {\n      S.Diag(Other->getLocation(), diag::note_conflicting_attribute);"},{I,1866,"static void handleCPUSpecificAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Ensure we don\'t combine these with themselves, since that causes some\n  // confusing behavior.\n  if (AL.getParsedKind() == ParsedAttr::AT_CPUDispatch) {\n  } else if (AL.getParsedKind() == ParsedAttr::AT_CPUSpecific) {\n    if (const auto *Other = D->getAttr<CPUSpecificAttr>()) {\n      S.Diag(Other->getLocation(), diag::note_conflicting_attribute);"},{I,3168,"static void handleTargetClonesAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  // Ensure we don\'t combine these with themselves, since that causes some\n  // confusing behavior.\n  if (const auto *Other = D->getAttr<TargetClonesAttr>()) {\n    S.Diag(Other->getLocation(), diag::note_conflicting_attribute);"},{I,3408,"ErrorAttr *Sema::mergeErrorAttr(Decl *D, const AttributeCommonInfo &CI, StringRef NewUserDiagnostic) {\n  if (const auto *EA = D->getAttr<ErrorAttr>()) {\n    if (!Match) {\n      Diag(CI.getLoc(), diag::note_conflicting_attribute);"},{I,4285,"AlwaysInlineAttr *Sema::mergeAlwaysInlineAttr(Decl *D, const AttributeCommonInfo &CI, const IdentifierInfo *Ident) {\n  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {\n    Diag(Optnone->getLocation(), diag::note_conflicting_attribute);"},{I,4333,"MinSizeAttr *Sema::mergeMinSizeAttr(Decl *D, const AttributeCommonInfo &CI) {\n  if (OptimizeNoneAttr *Optnone = D->getAttr<OptimizeNoneAttr>()) {\n    Diag(Optnone->getLocation(), diag::note_conflicting_attribute);"},{I,4347,"SwiftNameAttr *Sema::mergeSwiftNameAttr(Decl *D, const SwiftNameAttr &SNA, StringRef Name) {\n  if (const auto *PrevSNA = D->getAttr<SwiftNameAttr>()) {\n    if (PrevSNA->getName() != Name && !PrevSNA->isImplicit()) {\n      Diag(SNA.getLoc(), diag::note_conflicting_attribute);"},{I,4358,"OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI) {\n  if (AlwaysInlineAttr *Inline = D->getAttr<AlwaysInlineAttr>()) {\n    Diag(CI.getLoc(), diag::note_conflicting_attribute);"},{I,4363,"OptimizeNoneAttr *Sema::mergeOptimizeNoneAttr(Decl *D, const AttributeCommonInfo &CI) {\n  if (MinSizeAttr *MinSize = D->getAttr<MinSizeAttr>()) {\n    Diag(CI.getLoc(), diag::note_conflicting_attribute);"},{I,4626,"static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (AL.getKind() == ParsedAttr::AT_Owner) {\n    if (const auto *OAttr = D->getAttr<OwnerAttr>()) {\n      if (ExistingDerefType != ParmType.getTypePtrOrNull()) {\n        S.Diag(OAttr->getLocation(), diag::note_conflicting_attribute);"},{I,4640,"static void handleLifetimeCategoryAttr(Sema &S, Decl *D, const ParsedAttr &AL) {\n  if (AL.getKind() == ParsedAttr::AT_Owner) {\n  } else {\n    if (const auto *PAttr = D->getAttr<PointerAttr>()) {\n      if (ExistingDerefType != ParmType.getTypePtrOrNull()) {\n        S.Diag(PAttr->getLocation(), diag::note_conflicting_attribute);"},{I,4867,"void Sema::AddParameterABIAttr(Decl *D, const AttributeCommonInfo &CI, ParameterABI abi) {\n  if (auto existingAttr = D->getAttr<ParameterABIAttr>()) {\n    if (existingAttr->getABI() != abi) {\n      Diag(existingAttr->getLocation(), diag::note_conflicting_attribute);"},{I,6274,"HLSLNumThreadsAttr *Sema::mergeHLSLNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z) {\n  if (HLSLNumThreadsAttr *NT = D->getAttr<HLSLNumThreadsAttr>()) {\n    if (NT->getX() != X || NT->getY() != Y || NT->getZ() != Z) {\n      Diag(AL.getLoc(), diag::note_conflicting_attribute);"},{I,6360,"HLSLShaderAttr *Sema::mergeHLSLShaderAttr(Decl *D, const AttributeCommonInfo &AL, HLSLShaderAttr::ShaderType ShaderType) {\n  if (HLSLShaderAttr *NT = D->getAttr<HLSLShaderAttr>()) {\n    if (NT->getType() != ShaderType) {\n      Diag(AL.getLoc(), diag::note_conflicting_attribute);"},{I,7622,"template <typename AttrTy, typename ConflictingAttrTy> static AttrTy *mergeEnforceTCBAttrImpl(Sema &S, Decl *D, const AttrTy &AL) {\n  if (const ConflictingAttrTy *ConflictingAttr = findEnforceTCBAttrByName<ConflictingAttrTy>(D, TCBName)) {\n    S.Diag(AL.getLoc(), diag::note_conflicting_attribute);"},{A,819,"StmtResult Sema::ActOnIfStmt(SourceLocation IfLoc, IfStatementKind StatementKind, SourceLocation LParenLoc, Stmt *InitStmt, ConditionResult Cond, SourceLocation RParenLoc, Stmt *thenStmt, SourceLocation ElseLoc, Stmt *elseStmt) {\n  if (ConstevalOrNegatedConsteval || StatementKind == IfStatementKind::Constexpr) {\n  } else {\n    if (std::get<0>(LHC)) {\n      Diags.Report(ElseAttr->getLocation(), diag::note_conflicting_attribute) << ElseAttr << ElseAttr->getRange();"},{"clang/lib/Sema/SemaStmtAttr.cpp",207,"template <typename OtherAttr, int DiagIdx> static bool CheckStmtInlineAttr(Sema &SemaRef, const Stmt *OrigSt, const Stmt *CurSt, const AttributeCommonInfo &A) {\n  for (const auto &Tup : llvm::zip_longest(OrigCEF.getCallExprs(), CEF.getCallExprs())) {\n    // If the original call expression already had a callee, we already\n    // diagnosed this, so skip it here. We can\'t skip if there isn\'t a 1:1\n    // relationship between the two lists of call expressions.\n    if (!CanSuppressDiag || !(*std::get<0>(Tup))->getCalleeDecl()) {\n      if (Callee && (Callee->hasAttr<OtherAttr>() || Callee->hasAttr<FlattenAttr>())) {\n        SemaRef.Diag(Callee->getBeginLoc(), diag::note_conflicting_attribute);"},{"clang/utils/TableGen/ClangAttrEmitter.cpp",3498,"// Generates the mutual exclusion checks. The checks for parsed attributes are\n// written into OS and the checks for merging declaration attributes are\n// written into MergeOS.\nstatic void GenerateMutualExclusionsChecks(const Record &Attr, const RecordKeeper &Records, raw_ostream &OS, raw_ostream &MergeDeclOS, raw_ostream &MergeStmtOS) {\n  // If we discovered any decl or stmt attributes to test for, generate the\n  // predicates for them now.\n  if (!DeclAttrs.empty()) {\n    for (const std::string &A : DeclAttrs) {\n      OS << \"      S.Diag(A->getLocation(), diag::note_conflicting_attribute);\";"},{"clang/utils/TableGen/ClangAttrEmitter.cpp",3519,"// Generates the mutual exclusion checks. The checks for parsed attributes are\n// written into OS and the checks for merging declaration attributes are\n// written into MergeOS.\nstatic void GenerateMutualExclusionsChecks(const Record &Attr, const RecordKeeper &Records, raw_ostream &OS, raw_ostream &MergeDeclOS, raw_ostream &MergeStmtOS) {\n  // If we discovered any decl or stmt attributes to test for, generate the\n  // predicates for them now.\n  if (!DeclAttrs.empty()) {\n    // Also generate the declaration attribute merging logic if the current\n    // attribute is one that can be inheritted on a declaration. It is assumed\n    // this code will be executed in the context of a function with parameters:\n    // Sema &S, Decl *D, Attr *A and that returns a bool (false on diagnostic,\n    // true on success).\n    if (Attr.isSubClassOf(\"InheritableAttr\")) {\n      for (const std::string &A : DeclAttrs) {\n        MergeDeclOS << \"      S.Diag(Second->getLocation(), \"\n                    << \"diag::note_conflicting_attribute);\\n\";"},{"clang/utils/TableGen/ClangAttrEmitter.cpp",3558,"// Generates the mutual exclusion checks. The checks for parsed attributes are\n// written into OS and the checks for merging declaration attributes are\n// written into MergeOS.\nstatic void GenerateMutualExclusionsChecks(const Record &Attr, const RecordKeeper &Records, raw_ostream &OS, raw_ostream &MergeDeclOS, raw_ostream &MergeStmtOS) {\n  // Statement attributes are a bit different from declarations. With\n  // declarations, each attribute is added to the declaration as it is\n  // processed, and so you can look on the Decl * itself to see if there is a\n  // conflicting attribute. Statement attributes are processed as a group\n  // because AttributedStmt needs to tail-allocate all of the attribute nodes\n  // at once. This means we cannot check whether the statement already contains\n  // an attribute to check for the conflict. Instead, we need to check whether\n  // the given list of semantic attributes contain any conflicts. It is assumed\n  // this code will be executed in the context of a function with parameters:\n  // Sema &S, const SmallVectorImpl<const Attr *> &C. The code will be within a\n  // loop which loops over the container C with a loop variable named A to\n  // represent the current attribute to check for conflicts.\n  //\n  // FIXME: it would be nice not to walk over the list of potential attributes\n  // to apply to the statement more than once, but statements typically don\'t\n  // have long lists of attributes on them, so re-walking the list should not\n  // be an expensive operation.\n  if (!StmtAttrs.empty()) {\n    MergeStmtOS << \"        S.Diag(Second->getLocation(), \"\n                << \"diag::note_conflicting_attribute);\\n\";"}}

[n]={{t,3751,"/// 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  // C: Function types need to be compatible, not identical. This handles\n  // duplicate function decls like \"void f(int); void f(enum X);\" properly.\n  if (!getLangOpts().CPlusPlus) {\n    // If we are merging two functions where only one of them has a prototype,\n    // we may have enough information to decide to issue a diagnostic that the\n    // function without a protoype will change behavior in C2x. This handles\n    // cases like:\n    //  void i(); void i(int j);\n    //  void i(int j); void i();\n    //  void i(); void i(int j) {}\n    // See ActOnFinishFunctionBody() for other cases of the behavior change\n    // diagnostic. See GetFullTypeForDeclarator() for handling of a function\n    // type without a prototype.\n    if (New->hasWrittenPrototype() != Old->hasWrittenPrototype() && !New->isImplicit() && !Old->isImplicit()) {\n      if (WithProto->getNumParams() != 0) {\n        if (WithoutProto->getBuiltinID() == 0 && !WithoutProto->isImplicit()) {\n          // The reason the one without the prototype will be changing behavior\n          // is because of the one with the prototype, so note that so long as\n          // it\'s a user-visible declaration. There is one exception to this:\n          // when the new declaration is a definition without a prototype, the\n          // old declaration with a prototype is not the cause of the issue,\n          // and that does not need to be noted because the one with a\n          // prototype will not change behavior in C2x.\n          if (WithProto->getBuiltinID() == 0 && !WithProto->isImplicit() && !IsWithoutProtoADef)\n            Diag(WithProto->getLocation(), diag::note_conflicting_prototype);"}}

[n]={{A,3655,"StmtResult Sema::ActOnObjCAtTryStmt(SourceLocation AtLoc, Stmt *Try, MultiStmtArg CatchStmts, Stmt *Finally) {\n  if (FSI->FirstSEHTryLoc.isValid()) {\n    Diag(FSI->FirstSEHTryLoc, diag::note_conflicting_try_here) << \"\'__try\'\";"},{A,3869,"/// ActOnCXXTryBlock - Takes a try compound-statement and a number of\n/// handlers and creates a try statement from them.\nStmtResult Sema::ActOnCXXTryBlock(SourceLocation TryLoc, Stmt *TryBlock, ArrayRef<Stmt *> Handlers) {\n  // C++ try is incompatible with SEH __try.\n  if (!getLangOpts().Borland && FSI->FirstSEHTryLoc.isValid()) {\n    Diag(FSI->FirstSEHTryLoc, diag::note_conflicting_try_here) << \"\'__try\'\";"},{A,3948,"StmtResult Sema::ActOnSEHTryBlock(bool IsCXXTry, SourceLocation TryLoc, Stmt *TryBlock, Stmt *Handler) {\n  // SEH __try is incompatible with C++ try. Borland appears to support this,\n  // however.\n  if (!getLangOpts().Borland) {\n    if (FSI->FirstCXXOrObjCTryLoc.isValid()) {\n      Diag(FSI->FirstCXXOrObjCTryLoc, diag::note_conflicting_try_here) << (FSI->FirstTryType == sema::FunctionScopeInfo::TryLocIsCXX ? \"\'try\'\" : \"\'@try\'\");"}}

[n]={{p,1931,"/// Check that this reference or pointer core constant expression is a valid\n/// value for an address or reference constant expression. Return true if we\n/// can fold this expression, whether or not it\'s a constant expression.\nstatic bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, ConstantExprKind Kind, CheckedTemporaries &CheckedTemps) {\n  if (auto *FD = dyn_cast_or_null<FunctionDecl>(BaseVD); FD && FD->isImmediateFunction()) {\n    Info.FFDiag(Loc, diag::note_consteval_address_accessible) << !Type->isAnyPointerType();"},{p,2047,"/// Member pointers are constant expressions unless they point to a\n/// non-virtual dllimport member function.\nstatic bool CheckMemberPointerConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const APValue &Value, ConstantExprKind Kind) {\n  if (FD->isImmediateFunction()) {\n    Info.FFDiag(Loc, diag::note_consteval_address_accessible) << /*pointer*/ 0;"}}

[n]={{p,3682,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n  } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {\n    if (!Alloc) {\n      Info.FFDiag(E, diag::note_constexpr_access_deleted_object) << AK;"}}

[n]={{p,3363,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  // Walk the designator\'s path to find the subobject.\n  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {\n    if (ObjType->isArrayType()) {\n    } else if (ObjType->isAnyComplexType()) {\n    } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {\n      if (RD->isUnion()) {\n        if (!UnionField || UnionField->getCanonicalDecl() != Field->getCanonicalDecl()) {\n          if (I == N - 1 && handler.AccessKind == AK_Construct) {\n          } else {\n            Info.FFDiag(E, diag::note_constexpr_access_inactive_union_member) << handler.AccessKind << Field << !UnionField << UnionField;"},{w,80,"static bool CheckActive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  S.FFDiag(Loc, diag::note_constexpr_access_inactive_union_member) << AK << InactiveField << !ActiveField << ActiveField;"}}

[n]={{p,3112,"/// Diagnose an attempt to read from any unreadable field within the specified\n/// type, which might be a class type.\nstatic bool diagnoseMutableFields(EvalInfo &Info, const Expr *E, AccessKinds AK, QualType T) {\n  for (auto *Field : RD->fields()) {\n    // If we\'re actually going to read this field in some way, then it can\'t\n    // be mutable. If we\'re in a union, then assigning to a mutable field\n    // (even an empty one) can change the active member, so that\'s not OK.\n    // FIXME: Add core issue number for the union case.\n    if (Field->isMutable() && (RD->isUnion() || isReadByLvalueToRvalueConversion(Field->getType()))) {\n      Info.FFDiag(E, diag::note_constexpr_access_mutable, 1) << AK << Field;"},{p,3345,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  // Walk the designator\'s path to find the subobject.\n  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {\n    if (ObjType->isArrayType()) {\n    } else if (ObjType->isAnyComplexType()) {\n    } else if (const FieldDecl *Field = getAsField(Sub.Entries[I])) {\n      if (Field->isMutable() && !Obj.mayAccessMutableMembers(Info, handler.AccessKind)) {\n        Info.FFDiag(E, diag::note_constexpr_access_mutable, 1) << handler.AccessKind << Field;"},{w,219,"bool CheckMutable(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {\n  S.FFDiag(Loc, diag::note_constexpr_access_mutable, 1) << AK_Read << Field;"}}

[n]={{p,1452,"#endif\n  bool checkNullPointerForFoldAccess(EvalInfo &Info, const Expr *E, AccessKinds AK) {\n    return checkNullPointerDiagnosingWith([&Info, E, AK] { Info.FFDiag(E, diag::note_constexpr_access_null) << AK; });"},{p,3532,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (!LVal.Base) {\n    Info.FFDiag(E, diag::note_constexpr_access_null) << AK;"},{w,148,"bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  if (Ptr.isZero()) {\n    if (Ptr.isField())\n    else\n      S.FFDiag(Src, diag::note_constexpr_access_null) << AK;"}}

[n]={{p,3221,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {\n    if (Info.getLangOpts().CPlusPlus11)\n      Info.FFDiag(E, Sub.isOnePastTheEnd() ? diag::note_constexpr_access_past_end : diag::note_constexpr_access_unsized_array) << handler.AccessKind;"},{p,3308,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  // Walk the designator\'s path to find the subobject.\n  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {\n    if (ObjType->isArrayType()) {\n      if (CAT->getSize().ule(Index)) {\n        // Note, it should not be possible to form a pointer with a valid\n        // designator which points more than one past the end of the array.\n        if (Info.getLangOpts().CPlusPlus11)\n          Info.FFDiag(E, diag::note_constexpr_access_past_end) << handler.AccessKind;"},{p,3328,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  // Walk the designator\'s path to find the subobject.\n  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {\n    if (ObjType->isArrayType()) {\n    } else if (ObjType->isAnyComplexType()) {\n      if (Index > 1) {\n        if (Info.getLangOpts().CPlusPlus11)\n          Info.FFDiag(E, diag::note_constexpr_access_past_end) << handler.AccessKind;"},{p,3833,"/// Perform an lvalue-to-rvalue conversion on the given glvalue. This\n/// can also be used for \'lvalue-to-lvalue\' conversions for looking up the\n/// glvalue referred to by an entity of reference type.\n///\n/// \\param Info - Information about the ongoing evaluation.\n/// \\param Conv - The expression for which we are performing the conversion.\n///              Used for diagnostics.\n/// \\param Type - The type of the glvalue (before stripping cv-qualifiers in the\n///              case of a non-class type).\n/// \\param LVal - The glvalue on which we are attempting to perform this action.\n/// \\param RVal - The produced value will be placed here.\n/// \\param WantObjectRepresentation - If true, we\'re looking for the object\n///              representation rather than the value, and in particular,\n///              there is no requirement that the result be fully initialized.\nstatic bool handleLValueToRValueConversion(EvalInfo &Info, const Expr *Conv, QualType Type, const LValue &LVal, APValue &RVal, bool WantObjectRepresentation = false) {\n  if (Base && !LVal.getLValueCallIndex() && !Type.isVolatileQualified()) {\n    if (const CompoundLiteralExpr *CLE = dyn_cast<CompoundLiteralExpr>(Base)) {\n    } else if (isa<StringLiteral>(Base) || isa<PredefinedExpr>(Base)) {\n      if (LVal.Designator.isOnePastTheEnd()) {\n        if (Info.getLangOpts().CPlusPlus11)\n          Info.FFDiag(Conv, diag::note_constexpr_access_past_end) << AK;"},{p,5064,"/// Check that we can access the notional vptr of an object / determine its\n/// dynamic type.\nstatic bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This, AccessKinds AK, bool Polymorphic) {\n  if (!Obj.Value) {\n    // The object is not usable in constant expressions, so we can\'t inspect\n    // its value to see if it\'s in-lifetime or what the active union members\n    // are. We can still check for a one-past-the-end lvalue.\n    if (This.Designator.isOnePastTheEnd() || This.Designator.isMostDerivedAnUnsizedArray()) {\n      Info.FFDiag(E, This.Designator.isOnePastTheEnd() ? diag::note_constexpr_access_past_end : diag::note_constexpr_access_unsized_array) << AK;"},{w,182,"bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  S.FFDiag(Loc, diag::note_constexpr_access_past_end) << AK;"}}

[n]={{p,3721,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n  } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {\n  } else {\n    if (!Frame) {\n      if (const MaterializeTemporaryExpr *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) {\n        // C++20 [expr.const]p4: [DR2126]\n        //  An object or reference is usable in constant expressions if it is\n        //  - a temporary object of non-volatile const-qualified literal type\n        //    whose lifetime is extended to that of a variable that is usable\n        //    in constant expressions\n        //\n        // C++20 [expr.const]p5:\n        //  an lvalue-to-rvalue conversion [is not allowed unless it applies to]\n        //  - a non-volatile glvalue that refers to an object that is usable\n        //    in constant expressions, or\n        //  - a non-volatile glvalue of literal type that refers to a\n        //    non-volatile object whose lifetime began within the evaluation\n        //    of E;\n        //\n        // C++11 misses the \'began within the evaluation of e\' check and\n        // instead allows all temporaries, including things like:\n        //  int &&r = 1;\n        //  int x = ++r;\n        //  constexpr int k = r;\n        // Therefore we use the C++14-onwards rules in C++11 too.\n        //\n        // Note that temporaries whose lifetimes began while evaluating a\n        // variable\'s constructor are not usable while evaluating the\n        // corresponding destructor, not even if they\'re of const-qualified\n        // types.\n        if (!MTE->isUsableInConstantExpressions(Info.Ctx) && !lifetimeStartedInEvaluation(Info, LVal.Base)) {\n          Info.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;"},{w,96,"static bool CheckTemporary(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  if (auto ID = Ptr.getDeclID()) {\n    S.FFDiag(E, diag::note_constexpr_access_static_temporary, 1) << AK;"}}

[n]={{p,3237,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  // Walk the designator\'s path to find the subobject.\n  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {\n    // Reading an indeterminate value is undefined, but assigning over one is OK.\n    if ((O->isAbsent() && !(handler.AccessKind == AK_Construct && I == N)) || (O->isIndeterminate() && !isValidIndeterminateAccess(handler.AccessKind))) {\n      if (!Info.checkingPotentialConstantExpression())\n        Info.FFDiag(E, diag::note_constexpr_access_uninit) << handler.AccessKind << O->isIndeterminate();"},{w,230,"bool CheckInitialized(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  if (!S.checkingPotentialConstantExpression()) {\n    S.FFDiag(Loc, diag::note_constexpr_access_uninit) << AK << /*uninitialized=*/true;"}}

[n]={{p,3733,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n  } else if (DynamicAllocLValue DA = LVal.Base.dyn_cast<DynamicAllocLValue>()) {\n  } else {\n    if (!Frame) {\n      if (const MaterializeTemporaryExpr *MTE = dyn_cast_or_null<MaterializeTemporaryExpr>(Base)) {\n      } else {\n        Info.FFDiag(E, diag::note_constexpr_access_unreadable_object) << AK << Val.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(LValType));"}}

[n]={{p,3221,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  if (Sub.isOnePastTheEnd() || Sub.isMostDerivedAnUnsizedArray()) {\n    if (Info.getLangOpts().CPlusPlus11)\n      Info.FFDiag(E, Sub.isOnePastTheEnd() ? diag::note_constexpr_access_past_end : diag::note_constexpr_access_unsized_array) << handler.AccessKind;"},{p,5064,"/// Check that we can access the notional vptr of an object / determine its\n/// dynamic type.\nstatic bool checkDynamicType(EvalInfo &Info, const Expr *E, const LValue &This, AccessKinds AK, bool Polymorphic) {\n  if (!Obj.Value) {\n    // The object is not usable in constant expressions, so we can\'t inspect\n    // its value to see if it\'s in-lifetime or what the active union members\n    // are. We can still check for a one-past-the-end lvalue.\n    if (This.Designator.isOnePastTheEnd() || This.Designator.isMostDerivedAnUnsizedArray()) {\n      Info.FFDiag(E, This.Designator.isOnePastTheEnd() ? diag::note_constexpr_access_past_end : diag::note_constexpr_access_unsized_array) << AK;"}}

[n]={{p,3271,"/// Find the designated sub-object of an rvalue.\ntemplate <typename SubobjectHandler> typename SubobjectHandler::result_type findSubobject(EvalInfo &Info, const Expr *E, const CompleteObject &Obj, const SubobjectDesignator &Sub, SubobjectHandler &handler) {\n  // Walk the designator\'s path to find the subobject.\n  for (unsigned I = 0, N = Sub.Entries.size(); /**/; ++I) {\n    // If this is our last pass, check that the final object type is OK.\n    if (I == N || (I == N - 1 && ObjType->isAnyComplexType())) {\n      // Accesses to volatile objects are prohibited.\n      if (ObjType.isVolatileQualified() && isFormalAccess(handler.AccessKind)) {\n        if (Info.getLangOpts().CPlusPlus) {\n          Info.FFDiag(E, diag::note_constexpr_access_volatile_obj, 1) << handler.AccessKind << DiagKind << Decl;"}}

[n]={{p,3555,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  // C++11 DR1311: An lvalue-to-rvalue conversion on a volatile-qualified type\n  // is not a constant expression (even if the object is non-volatile). We also\n  // apply this rule to C++98, in order to conform to the expected \'volatile\'\n  // semantics.\n  if (isFormalAccess(AK) && LValType.isVolatileQualified()) {\n    if (Info.getLangOpts().CPlusPlus)\n      Info.FFDiag(E, diag::note_constexpr_access_volatile_type) << AK << LValType;"}}

[n]={{p,8262,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_align_down: {\n    Info.FFDiag(E->getArg(0), diag::note_constexpr_alignment_adjust) << Alignment;"}}

[n]={{p,10707,"bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_is_aligned: {\n    if (Src.isLValue()) {\n      Info.FFDiag(E->getArg(0), diag::note_constexpr_alignment_compute) << Alignment;"}}

[n]={{p,8145,"/// Evaluate the value of the alignment argument to __builtin_align_{up,down},\n/// __builtin_is_aligned and __builtin_assume_aligned.\nstatic bool getAlignmentArgument(const Expr *E, QualType ForType, EvalInfo &Info, APSInt &Alignment) {\n  if (APSInt::compareValues(Alignment, MaxValue) > 0) {\n    Info.FFDiag(E, diag::note_constexpr_alignment_too_big) << MaxValue << ForType << Alignment;"}}

[n]={{p,1258,"void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info, const Expr *E, const APSInt &N) {\n  // If we\'re complaining, we must be able to statically determine the size of\n  // the most derived array.\n  if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)\n    Info.CCEDiag(E, diag::note_constexpr_array_index) << N << /*array*/ 0 << static_cast<unsigned>(getMostDerivedArraySize());"},{p,1260,"void SubobjectDesignator::diagnosePointerArithmetic(EvalInfo &Info, const Expr *E, const APSInt &N) {\n  // If we\'re complaining, we must be able to statically determine the size of\n  // the most derived array.\n  if (MostDerivedPathLength == Entries.size() && MostDerivedIsArrayElement)\n  else\n    Info.CCEDiag(E, diag::note_constexpr_array_index) << N << /*non-array*/ 1;"}}

[n]={{p,8219,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_assume_aligned: {\n    // If there is a base object, then it must have the correct alignment.\n    if (OffsetResult.Base) {\n      if (BaseAlignment < Align) {\n        CCEDiag(E->getArg(0), diag::note_constexpr_baa_insufficient_alignment) << 0 << (unsigned)BaseAlignment.getQuantity() << (unsigned)Align.getQuantity();"},{p,8228,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_assume_aligned: {\n    // The offset must also have the correct alignment.\n    if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {\n      (OffsetResult.Base ? CCEDiag(E->getArg(0), diag::note_constexpr_baa_insufficient_alignment) << 1 : CCEDiag(E->getArg(0), diag::note_constexpr_baa_value_insufficient_alignment)) << (int)OffsetResult.Offset.getQuantity() << (unsigned)Align.getQuantity();"}}

[n]={{p,8228,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_assume_aligned: {\n    // The offset must also have the correct alignment.\n    if (OffsetResult.Offset.alignTo(Align) != OffsetResult.Offset) {\n      (OffsetResult.Base ? CCEDiag(E->getArg(0), diag::note_constexpr_baa_insufficient_alignment) << 1 : CCEDiag(E->getArg(0), diag::note_constexpr_baa_value_insufficient_alignment)) << (int)OffsetResult.Offset.getQuantity() << (unsigned)Align.getQuantity();"}}

[n]={{p,6364,"/// Write an BitCastBuffer into an APValue.\nclass BufferToAPValueConverter {\n  std::optional<APValue> visit(const BuiltinType *T, CharUnits Offset, const EnumType *EnumSugar = nullptr) {\n    if (!Buffer.readObject(Offset, SizeOf, Bytes)) {\n      if (!IsStdByte && !IsUChar) {\n        Info.FFDiag(BCE->getExprLoc(), diag::note_constexpr_bit_cast_indet_dest) << DisplayType << Info.Ctx.getLangOpts().CharIsSigned;"}}

[n]={{p,6512,"static bool checkBitCastConstexprEligibilityType(SourceLocation Loc, QualType Ty, EvalInfo *Info, const ASTContext &Ctx, bool CheckingDest) {\n  auto note = [&](int Construct, QualType NoteTy, SourceLocation NoteLoc) {\n    if (Info)\n      Info->Note(NoteLoc, diag::note_constexpr_bit_cast_invalid_subtype) << NoteTy << Construct << Ty;"}}

[n]={{p,6507,"static bool checkBitCastConstexprEligibilityType(SourceLocation Loc, QualType Ty, EvalInfo *Info, const ASTContext &Ctx, bool CheckingDest) {\n  auto diag = [&](int Reason) {\n    if (Info)\n      Info->FFDiag(Loc, diag::note_constexpr_bit_cast_invalid_type) << CheckingDest << (Reason == 4) << Reason;"}}

[n]={{p,6331,"/// Write an BitCastBuffer into an APValue.\nclass BufferToAPValueConverter {\n  std::nullopt_t unrepresentableValue(QualType Ty, const APSInt &Val) {\n    Info.FFDiag(BCE->getBeginLoc(), diag::note_constexpr_bit_cast_unrepresentable_value) << Ty << toString(Val, /*Radix=*/10);"}}

[n]={{p,6241,"/// Traverse an APValue to produce an BitCastBuffer, emulating how the current\n/// target would represent the value at runtime.\nclass APValueToBufferConverter {\n  bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) {\n    for (FieldDecl *FD : RD->fields()) {\n      if (FD->isBitField()) {\n        Info.FFDiag(BCE->getBeginLoc(), diag::note_constexpr_bit_cast_unsupported_bitfield);"},{p,6427,"/// Write an BitCastBuffer into an APValue.\nclass BufferToAPValueConverter {\n  std::optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {\n    for (FieldDecl *FD : RD->fields()) {\n      // FIXME: We don\'t currently support bit-fields. A lot of the logic for\n      // this is in CodeGen, so we need to factor it around.\n      if (FD->isBitField()) {\n        Info.FFDiag(BCE->getBeginLoc(), diag::note_constexpr_bit_cast_unsupported_bitfield);"}}

[n]={{p,6212,"/// Traverse an APValue to produce an BitCastBuffer, emulating how the current\n/// target would represent the value at runtime.\nclass APValueToBufferConverter {\n  // Write out Val with type Ty into Buffer starting at Offset.\n  bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {\n    case APValue::AddrLabelDiff: {\n      Info.FFDiag(BCE->getBeginLoc(), diag::note_constexpr_bit_cast_unsupported_type) << Ty;"},{p,6326,"/// Write an BitCastBuffer into an APValue.\nclass BufferToAPValueConverter {\n  // Emit an unsupported bit_cast type error. Sema refuses to build a bit_cast\n  // with an invalid type, so anything left is a deficiency on our part (FIXME).\n  // Ideally this will be unreachable.\n  std::nullopt_t unsupportedType(QualType Ty) {\n    Info.FFDiag(BCE->getBeginLoc(), diag::note_constexpr_bit_cast_unsupported_type) << Ty;"}}

[n]={{q,2030,"/// Check the body for the given constexpr function declaration only contains\n/// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.\n///\n/// \\return true if the body is OK, false if we have found or diagnosed a\n/// problem.\nstatic bool CheckConstexprFunctionBody(Sema &SemaRef, const FunctionDecl *Dcl, Stmt *Body, Sema::CheckConstexprKind Kind) {\n  if (const CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Dcl)) {\n  } else {\n    if (ReturnStmts.empty()) {\n    } else if (ReturnStmts.size() > 1) {\n      case Sema::CheckConstexprKind::Diagnose:\n        for (unsigned I = 0; I < ReturnStmts.size() - 1; ++I)\n          SemaRef.Diag(ReturnStmts[I], diag::note_constexpr_body_previous_return);"}}

[n]={{"clang/lib/AST/Interp/State.cpp",137,"void State::addCallStack(unsigned Limit) {\n  for (const Frame *F = Top; F != Bottom; F = F->getCaller(), ++CallIdx) {\n    addDiag(CallLocation, diag::note_constexpr_call_here) << Out.str();"}}

[n]={{p,877,"/// EvalInfo - This is a private struct used by the evaluator to capture\n/// information about a subexpression as it is folded.  It retains information\n/// about the AST context, but also maintains information about the folded\n/// expression.\n///\n/// If an expression could be evaluated, it is still possible it is not a C\n/// \"integer constant expression\" or constant expression.  If not, this struct\n/// captures information about how and why not.\n///\n/// One bit of information passed *into* the request for constant folding\n/// indicates whether the subexpression is \"evaluated\" or not according to C\n/// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can\n/// evaluate the expression regardless of what the RHS is, but C only allows\n/// certain things in certain situations.\nclass EvalInfo : public interp::State {\n  bool CheckCallLimit(SourceLocation Loc) {\n    if (NextCallIndex == 0) {\n      FFDiag(Loc, diag::note_constexpr_call_limit_exceeded);"}}

[n]={{"clang/lib/AST/Interp/State.cpp",122,"void State::addCallStack(unsigned Limit) {\n  for (const Frame *F = Top; F != Bottom; F = F->getCaller(), ++CallIdx) {\n    // Skip this call?\n    if (CallIdx >= SkipStart && CallIdx < SkipEnd) {\n      if (CallIdx == SkipStart) {\n        addDiag(CallLocation, diag::note_constexpr_calls_suppressed) << unsigned(ActiveCalls - Limit);"}}

[n]={{p,11791,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isMemberPointerType()) {\n    //  Otherwise if either is a pointer to a virtual member function, the\n    //  result is unspecified.\n    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(LHSValue.getDecl()))\n      if (MD->isVirtual())\n        Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;"},{p,11794,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isMemberPointerType()) {\n    if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(RHSValue.getDecl()))\n      if (MD->isVirtual())\n        Info.CCEDiag(E, diag::note_constexpr_compare_virtual_mem_ptr) << MD;"}}

[n]={{p,6607,"template <class Derived> class ExprEvaluatorBase : public ConstStmtVisitor<Derived, bool> {\n  // Check whether a conditional operator with a non-constant condition is a\n  // potential constant expression. If neither arm is a potential constant\n  // expression, then the conditional operator is not either.\n  template <typename ConditionalOperator> void CheckPotentialConstantConditional(const ConditionalOperator *E) {\n    Error(E, diag::note_constexpr_conditional_never_const);"}}

[n]={{p,8636,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (IsPlacement) {\n    struct FindObjectHandler {\n      bool found(APSInt &Value, QualType SubobjType) {\n        Info.FFDiag(E, diag::note_constexpr_construct_complex_elem);"},{p,8640,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (IsPlacement) {\n    struct FindObjectHandler {\n      bool found(APFloat &Value, QualType SubobjType) {\n        Info.FFDiag(E, diag::note_constexpr_construct_complex_elem);"}}

[n]={{q,1741,"/// Check that the given field is initialized within a constexpr constructor.\n///\n/// \\param Dcl The constexpr constructor being checked.\n/// \\param Field The field being checked. This may be a member of an anonymous\n///        struct or union nested within the class being checked.\n/// \\param Inits All declarations, including anonymous struct/union members and\n///        indirect members, for which any initialization was provided.\n/// \\param Diagnosed Whether we\'ve emitted the error message yet. Used to attach\n///        multiple notes for different members to the same error.\n/// \\param Kind Whether we\'re diagnosing a constructor as written or determining\n///        whether the formal requirements are satisfied.\n/// \\return \\c false if we\'re checking for validity and the constructor does\n///        not satisfy the requirements on a constexpr constructor.\nstatic bool CheckConstexprCtorInitializer(Sema &SemaRef, const FunctionDecl *Dcl, FieldDecl *Field, llvm::SmallSet<Decl *, 16> &Inits, bool &Diagnosed, Sema::CheckConstexprKind Kind) {\n  if (!Inits.count(Field)) {\n    if (Kind == Sema::CheckConstexprKind::Diagnose) {\n      SemaRef.Diag(Field->getLocation(), diag::note_constexpr_ctor_missing_init);"}}

[n]={{p,6110,"// Perform a call to \'operator delete\' or \'__builtin_operator_delete\'.\nbool HandleOperatorDeleteCall(EvalInfo &Info, const CallExpr *E) {\n  // Deleting a null pointer would have no effect, but it\'s not permitted by\n  // std::allocator<T>::deallocate\'s contract.\n  if (Pointer.isNullPointer()) {\n    Info.CCEDiag(E->getExprLoc(), diag::note_constexpr_deallocate_null);"}}

[n]={{p,13439,"bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {\n  // For the non-array case, the designator must be empty if the static type\n  // does not have a virtual destructor.\n  if (!E->isArrayForm() && Pointer.Designator.Entries.size() != 0 && !hasVirtualDestructor(Arg->getType()->getPointeeType())) {\n    Info.FFDiag(E, diag::note_constexpr_delete_base_nonvirt_dtor) << Arg->getType()->getPointeeType() << AllocType;"}}

[n]={{p,6054,"/// Check that the given object is a suitable pointer to a heap allocation that\n/// still exists and is of the right kind for the purpose of a deletion.\n///\n/// On success, returns the heap allocation to deallocate. On failure, produces\n/// a diagnostic and returns std::nullopt.\nstatic std::optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E, const LValue &Pointer, DynAlloc::Kind DeallocKind) {\n  if (!DA) {\n    Info.FFDiag(E, diag::note_constexpr_delete_not_heap_alloc) << PointerAsString();"}}

[n]={{p,6080,"/// Check that the given object is a suitable pointer to a heap allocation that\n/// still exists and is of the right kind for the purpose of a deletion.\n///\n/// On success, returns the heap allocation to deallocate. On failure, produces\n/// a diagnostic and returns std::nullopt.\nstatic std::optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E, const LValue &Pointer, DynAlloc::Kind DeallocKind) {\n  if (Subobject) {\n    Info.FFDiag(E, diag::note_constexpr_delete_subobject) << PointerAsString() << Pointer.Designator.isOnePastTheEnd();"}}

[n]={{p,882,"/// EvalInfo - This is a private struct used by the evaluator to capture\n/// information about a subexpression as it is folded.  It retains information\n/// about the AST context, but also maintains information about the folded\n/// expression.\n///\n/// If an expression could be evaluated, it is still possible it is not a C\n/// \"integer constant expression\" or constant expression.  If not, this struct\n/// captures information about how and why not.\n///\n/// One bit of information passed *into* the request for constant folding\n/// indicates whether the subexpression is \"evaluated\" or not according to C\n/// rules.  For example, the RHS of (0 && foo()) is not evaluated.  We can\n/// evaluate the expression regardless of what the RHS is, but C only allows\n/// certain things in certain situations.\nclass EvalInfo : public interp::State {\n  bool CheckCallLimit(SourceLocation Loc) {\n    FFDiag(Loc, diag::note_constexpr_depth_limit_exceeded) << getLangOpts().ConstexprCallDepth;"},{w,331,"bool CheckCallDepth(InterpState &S, CodePtr OpPC) {\n  if ((S.Current->getDepth() + 1) > S.getLangOpts().ConstexprCallDepth) {\n    S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_depth_limit_exceeded) << S.getLangOpts().ConstexprCallDepth;"}}

[n]={{p,5944,"struct DestroyObjectHandler {\n  bool found(APSInt &Value, QualType SubobjType) {\n    Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem);"},{p,5948,"struct DestroyObjectHandler {\n  bool found(APFloat &Value, QualType SubobjType) {\n    Info.FFDiag(E, diag::note_constexpr_destroy_complex_elem);"}}

[n]={{p,5785,"static bool HandleDestructionImpl(EvalInfo &Info, SourceLocation CallLoc, const LValue &This, APValue &Value, QualType T) {\n  // Objects can only be destroyed while they\'re within their lifetimes.\n  // FIXME: We have no representation for whether an object of type nullptr_t\n  // is in its lifetime; it usually doesn\'t matter. Perhaps we should model it\n  // as indeterminate instead?\n  if (Value.isAbsent() && !T->isNullPtrType()) {\n    Info.FFDiag(CallLoc, diag::note_constexpr_destroy_out_of_lifetime) << Printable.getAsString(Info.Ctx, Info.Ctx.getLValueReferenceType(T));"}}

[n]={{p,6062,"/// Check that the given object is a suitable pointer to a heap allocation that\n/// still exists and is of the right kind for the purpose of a deletion.\n///\n/// On success, returns the heap allocation to deallocate. On failure, produces\n/// a diagnostic and returns std::nullopt.\nstatic std::optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E, const LValue &Pointer, DynAlloc::Kind DeallocKind) {\n  if (!Alloc) {\n    Info.FFDiag(E, diag::note_constexpr_double_delete);"},{p,13461,"bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {\n  if (!Info.HeapAllocs.erase(Pointer.Base.dyn_cast<DynamicAllocLValue>())) {\n    Info.FFDiag(E, diag::note_constexpr_double_delete);"}}

[n]={{p,5877,"static bool HandleDestructionImpl(EvalInfo &Info, SourceLocation CallLoc, const LValue &This, APValue &Value, QualType T) {\n  if (!EvalObj.DidInsert) {\n    Info.FFDiag(CallLoc, diag::note_constexpr_double_destroy);"}}

[n]={{q,1449,"/// Determine whether a destructor cannot be constexpr due to\nstatic bool CheckConstexprDestructorSubobjects(Sema &SemaRef, const CXXDestructorDecl *DD, Sema::CheckConstexprKind Kind) {\n  auto Check = [&](SourceLocation Loc, QualType T, const FieldDecl *FD) {\n    if (Kind == Sema::CheckConstexprKind::Diagnose) {\n      SemaRef.Diag(Loc, diag::note_constexpr_dtor_subobject) << !FD << (FD ? FD->getDeclName() : DeclarationName()) << T;"}}

[n]={{p,1962,"/// Check that this reference or pointer core constant expression is a valid\n/// value for an address or reference constant expression. Return true if we\n/// can fold this expression, whether or not it\'s a constant expression.\nstatic bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, ConstantExprKind Kind, CheckedTemporaries &CheckedTemps) {\n  if (Base.is<DynamicAllocLValue>()) {\n    Info.FFDiag(Loc, diag::note_constexpr_dynamic_alloc) << IsReferenceType << !Designator.Entries.empty();"}}

[n]={{p,1878,"static void NoteLValueLocation(EvalInfo &Info, APValue::LValueBase Base) {\n  if (VD)\n  else if (const Expr *E = Base.dyn_cast<const Expr *>())\n  else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {\n    // FIXME: Produce a note for dangling pointers too.\n    if (std::optional<DynAlloc *> Alloc = Info.lookupDynamicAlloc(DA))\n      Info.Note((*Alloc)->AllocExpr->getExprLoc(), diag::note_constexpr_dynamic_alloc_here);"}}

[n]={{p,5287,"/// Apply the given dynamic cast operation on the provided lvalue.\n///\n/// This implements the hard case of dynamic_cast, requiring a \"runtime check\"\n/// to find a suitable target subobject.\nstatic bool HandleDynamicCast(EvalInfo &Info, const ExplicitCastExpr *E, LValue &Ptr) {\n  auto RuntimeCheckFailed = [&](CXXBasePaths *Paths) {\n    Info.FFDiag(E, diag::note_constexpr_dynamic_cast_to_reference_failed) << DiagKind << Ptr.Designator.getType(Info.Ctx) << Info.Ctx.getRecordType(DynType->Type) << E->getType().getUnqualifiedType();"}}

[n]={{p,2291,"/// Check if the given evaluation result is allowed for constant evaluation.\nstatic bool checkFloatingPointResult(EvalInfo &Info, const Expr *E, APFloat::opStatus St) {\n  if ((St & APFloat::opInexact) && FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {\n    Info.FFDiag(E, diag::note_constexpr_dynamic_rounding);"},{w,451,"bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status) {\n  if ((Status & APFloat::opInexact) && FPO.getRoundingMode() == llvm::RoundingMode::Dynamic) {\n    S.FFDiag(E, diag::note_constexpr_dynamic_rounding);"}}

[n]={{p,2567,"/// Perform the given binary floating-point operation, in-place, on LHS.\nstatic bool handleFloatFloatBinOp(EvalInfo &Info, const BinaryOperator *E, APFloat &LHS, BinaryOperatorKind Opcode, const APFloat &RHS) {\n  // [expr.pre]p4:\n  //  If during the evaluation of an expression, the result is not\n  //  mathematically defined [...], the behavior is undefined.\n  // FIXME: C++ rules require us to not conform to IEEE 754 here.\n  if (LHS.isNaN()) {\n    Info.CCEDiag(E, diag::note_constexpr_float_arithmetic) << LHS.isNaN();"}}

[n]={{p,2296,"/// Check if the given evaluation result is allowed for constant evaluation.\nstatic bool checkFloatingPointResult(EvalInfo &Info, const Expr *E, APFloat::opStatus St) {\n  if ((St != APFloat::opOK) && (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic || FPO.getExceptionMode() != LangOptions::FPE_Ignore || FPO.getAllowFEnvAccess())) {\n    Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);"},{p,11606,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isRealFloatingType() && RHSTy->isRealFloatingType()) {\n    if (!Info.InConstantContext && APFloatCmpResult == APFloat::cmpUnordered && E->getFPFeaturesInEffect(Info.Ctx.getLangOpts()).isFPConstrained()) {\n      Info.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);"},{w,456,"bool CheckFloatResult(InterpState &S, CodePtr OpPC, APFloat::opStatus Status) {\n  if ((Status != APFloat::opOK) && (FPO.getRoundingMode() == llvm::RoundingMode::Dynamic || FPO.getExceptionMode() != LangOptions::FPE_Ignore || FPO.getAllowFEnvAccess())) {\n    S.FFDiag(E, diag::note_constexpr_float_arithmetic_strict);"}}

[n]={{p,2915,"/// Try to evaluate the initializer for a variable declaration.\n///\n/// \\param Info  Information about the ongoing evaluation.\n/// \\param E      An expression to be used when printing diagnostics.\n/// \\param VD    The variable whose initializer should be obtained.\n/// \\param Version The version of the variable within the frame.\n/// \\param Frame  The frame in which the variable was created. Must be null\n///              if this variable is not local to the evaluation.\n/// \\param Result Filled in with a pointer to the value of the variable.\nstatic bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, const VarDecl *VD, CallStackFrame *Frame, unsigned Version, APValue *&Result) {\n  if (isa<ParmVarDecl>(VD)) {\n    // Assume parameters of a potential constant expression are usable in\n    // constant expressions.\n    if (!Info.checkingPotentialConstantExpression() || !Info.CurrentCall->Callee || !Info.CurrentCall->Callee->Equals(VD->getDeclContext())) {\n      if (Info.getLangOpts().CPlusPlus11) {\n        Info.FFDiag(E, diag::note_constexpr_function_param_value_unknown) << VD;"}}

[n]={{p,1671,"APValue *EvalInfo::createHeapAlloc(const Expr *E, QualType T, LValue &LV) {\n  if (NumHeapAllocs > DynamicAllocLValue::getMaxIndex()) {\n    FFDiag(E, diag::note_constexpr_heap_alloc_limit_exceeded);"}}

[n]={{"clang/lib/AST/Interp/State.cpp",130,"void State::addCallStack(unsigned Limit) {\n  for (const Frame *F = Top; F != Bottom; F = F->getCaller(), ++CallIdx) {\n    // Use a different note for an inheriting constructor, because from the\n    // user\'s perspective it\'s not really a function at all.\n    if (const auto *CD = dyn_cast_if_present<CXXConstructorDecl>(F->getCallee()); CD && CD->isInheritingConstructor()) {\n      addDiag(CallLocation, diag::note_constexpr_inherited_ctor_call_here) << CD->getParent();"}}

[n]={{p,8139,"/// Evaluate the value of the alignment argument to __builtin_align_{up,down},\n/// __builtin_is_aligned and __builtin_assume_aligned.\nstatic bool getAlignmentArgument(const Expr *E, QualType ForType, EvalInfo &Info, APSInt &Alignment) {\n  if (Alignment < 0 || !Alignment.isPowerOf2()) {\n    Info.FFDiag(E, diag::note_constexpr_invalid_alignment) << Alignment;"}}

[n]={{p,6695,"template <class Derived> class ExprEvaluatorBase : public ConstStmtVisitor<Derived, bool> {\n  bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E) {\n    CCEDiag(E, diag::note_constexpr_invalid_cast) << 0;"},{p,6700,"template <class Derived> class ExprEvaluatorBase : public ConstStmtVisitor<Derived, bool> {\n  bool VisitCXXDynamicCastExpr(const CXXDynamicCastExpr *E) {\n    if (!Info.Ctx.getLangOpts().CPlusPlus20)\n      CCEDiag(E, diag::note_constexpr_invalid_cast) << 1;"},{p,7333,"class LValueExprEvaluator : public LValueExprEvaluatorBase<LValueExprEvaluator> {\n  bool VisitCastExpr(const CastExpr *E) {\n    case CK_LValueBitCast:\n      this->CCEDiag(E, diag::note_constexpr_invalid_cast) << 2 << Info.Ctx.getLangOpts().CPlusPlus;"},{p,7985,"bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {\n  case CK_AddressSpaceConversion:\n    // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are\n    // permitted in constant expressions in C++11. Bitcasts from cv void* are\n    // also static_casts, but we disallow them as a resolution to DR1312.\n    if (!E->getType()->isVoidPointerType()) {\n      // 1. We\'ll allow it in std::allocator::allocate, and anything which that\n      //    calls.\n      // 2. HACK 2022-03-28: Work around an issue with libstdc++\'s\n      //    <source_location> header. Fixed in GCC 12 and later (2022-04-??).\n      //    We\'ll allow it in the body of std::source_location::current.  GCC\'s\n      //    implementation had a parameter of type `void*`, and casts from\n      //    that back to `const __impl*` in its body.\n      if (VoidPtrCastMaybeOK && (Info.getStdAllocatorCaller(\"allocate\") || IsDeclSourceLocationCurrent(Info.CurrentCall->Callee) || Info.getLangOpts().CPlusPlus26)) {\n      } else {\n        if (SubExpr->getType()->isVoidPointerType()) {\n          if (HasValidResult)\n          else\n            CCEDiag(E, diag::note_constexpr_invalid_cast) << 3 << SubExpr->getType();"},{p,7987,"bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {\n  case CK_AddressSpaceConversion:\n    // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are\n    // permitted in constant expressions in C++11. Bitcasts from cv void* are\n    // also static_casts, but we disallow them as a resolution to DR1312.\n    if (!E->getType()->isVoidPointerType()) {\n      // 1. We\'ll allow it in std::allocator::allocate, and anything which that\n      //    calls.\n      // 2. HACK 2022-03-28: Work around an issue with libstdc++\'s\n      //    <source_location> header. Fixed in GCC 12 and later (2022-04-??).\n      //    We\'ll allow it in the body of std::source_location::current.  GCC\'s\n      //    implementation had a parameter of type `void*`, and casts from\n      //    that back to `const __impl*` in its body.\n      if (VoidPtrCastMaybeOK && (Info.getStdAllocatorCaller(\"allocate\") || IsDeclSourceLocationCurrent(Info.CurrentCall->Callee) || Info.getLangOpts().CPlusPlus26)) {\n      } else {\n        if (SubExpr->getType()->isVoidPointerType()) {\n        } else\n          CCEDiag(E, diag::note_constexpr_invalid_cast) << 2 << Info.Ctx.getLangOpts().CPlusPlus;"},{p,8023,"bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {\n  case CK_IntegralToPointer: {\n    CCEDiag(E, diag::note_constexpr_invalid_cast) << 2 << Info.Ctx.getLangOpts().CPlusPlus;"},{p,12298,"/// HandleCast - This is used to evaluate implicit or explicit casts where the\n/// result type is integer.\nbool IntExprEvaluator::VisitCastExpr(const CastExpr *E) {\n  case CK_PointerToIntegral: {\n    CCEDiag(E, diag::note_constexpr_invalid_cast) << 2 << Info.Ctx.getLangOpts().CPlusPlus;"}}

[n]={{p,4252,"/// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on\n/// the provided lvalue, which currently refers to the base object.\nstatic bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E, LValue &Result) {\n  // Check this cast lands within the final derived-to-base subobject path.\n  if (D.MostDerivedPathLength + E->path_size() > D.Entries.size()) {\n    Info.CCEDiag(E, diag::note_constexpr_invalid_downcast) << D.MostDerivedType << TargetQT;"},{p,4266,"/// HandleBaseToDerivedCast - Apply the given base-to-derived cast operation on\n/// the provided lvalue, which currently refers to the base object.\nstatic bool HandleBaseToDerivedCast(EvalInfo &Info, const CastExpr *E, LValue &Result) {\n  if (FinalType->getCanonicalDecl() != TargetType->getCanonicalDecl()) {\n    Info.CCEDiag(E, diag::note_constexpr_invalid_downcast) << D.MostDerivedType << TargetQT;"}}

[n]={{p,4971,"/// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial\n/// default constructor. If so, we\'ll fold it whether or not it\'s marked as\n/// constexpr. If it is marked as constexpr, we will never implicitly define it,\n/// so we need special handling.\nstatic bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc, const CXXConstructorDecl *CD, bool IsValueInitialization) {\n  // Value-initialization does not call a trivial default constructor, so such a\n  // call is a core constant expression whether or not the constructor is\n  // constexpr.\n  if (!CD->isConstexpr() && !IsValueInitialization) {\n    if (Info.getLangOpts().CPlusPlus11) {\n      Info.CCEDiag(Loc, diag::note_constexpr_invalid_function, 1) << /*IsConstexpr*/ 0 << /*IsConstructor*/ 1 << CD;"},{p,5029,"/// CheckConstexprFunction - Check that a function can be called in a constant\n/// expression.\nstatic bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc, const FunctionDecl *Declaration, const FunctionDecl *Definition, const Stmt *Body) {\n  if (Info.getLangOpts().CPlusPlus11) {\n    // FIXME: If DiagDecl is an implicitly-declared special member function\n    // or an inheriting constructor, we should be much more explicit about why\n    // it\'s not constexpr.\n    if (CD && CD->isInheritingConstructor())\n    else\n      Info.FFDiag(CallLoc, diag::note_constexpr_invalid_function, 1) << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;"},{p,8274,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BIwmemchr:\n    if (Info.getLangOpts().CPlusPlus11)\n      Info.CCEDiag(E, diag::note_constexpr_invalid_function) << /*isConstexpr*/ 0 << /*isConstructor*/ 0 << (\"\'\" + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + \"\'\").str();"},{p,8367,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BIwmemmove:\n    if (Info.getLangOpts().CPlusPlus11)\n      Info.CCEDiag(E, diag::note_constexpr_invalid_function) << /*isConstexpr*/ 0 << /*isConstructor*/ 0 << (\"\'\" + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + \"\'\").str();"},{p,10954,"bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BIwcslen:\n    // A call to strlen is not a constant expression.\n    if (Info.getLangOpts().CPlusPlus11)\n      Info.CCEDiag(E, diag::note_constexpr_invalid_function) << /*isConstexpr*/ 0 << /*isConstructor*/ 0 << (\"\'\" + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + \"\'\").str();"},{p,10977,"bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BIwmemcmp:\n    // A call to strlen is not a constant expression.\n    if (Info.getLangOpts().CPlusPlus11)\n      Info.CCEDiag(E, diag::note_constexpr_invalid_function) << /*isConstexpr*/ 0 << /*isConstructor*/ 0 << (\"\'\" + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + \"\'\").str();"},{w,318,"bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {\n  if (!F->isConstexpr()) {\n    if (S.getLangOpts().CPlusPlus11) {\n      // FIXME: If DiagDecl is an implicitly-declared special member function\n      // or an inheriting constructor, we should be much more explicit about why\n      // it\'s not constexpr.\n      if (CD && CD->isInheritingConstructor())\n      else\n        S.FFDiag(Loc, diag::note_constexpr_invalid_function, 1) << DiagDecl->isConstexpr() << (bool)CD << DiagDecl;"}}

[n]={{p,5027,"/// CheckConstexprFunction - Check that a function can be called in a constant\n/// expression.\nstatic bool CheckConstexprFunction(EvalInfo &Info, SourceLocation CallLoc, const FunctionDecl *Declaration, const FunctionDecl *Definition, const Stmt *Body) {\n  if (Info.getLangOpts().CPlusPlus11) {\n    // FIXME: If DiagDecl is an implicitly-declared special member function\n    // or an inheriting constructor, we should be much more explicit about why\n    // it\'s not constexpr.\n    if (CD && CD->isInheritingConstructor())\n      Info.FFDiag(CallLoc, diag::note_constexpr_invalid_inhctor, 1) << CD->getInheritedConstructor().getConstructor()->getParent();"},{w,316,"bool CheckCallable(InterpState &S, CodePtr OpPC, const Function *F) {\n  if (!F->isConstexpr()) {\n    if (S.getLangOpts().CPlusPlus11) {\n      // FIXME: If DiagDecl is an implicitly-declared special member function\n      // or an inheriting constructor, we should be much more explicit about why\n      // it\'s not constexpr.\n      if (CD && CD->isInheritingConstructor())\n        S.FFDiag(Loc, diag::note_constexpr_invalid_inhctor, 1) << CD->getInheritedConstructor().getConstructor()->getParent();"}}

[n]={{p,1925,"/// Check that this reference or pointer core constant expression is a valid\n/// value for an address or reference constant expression. Return true if we\n/// can fold this expression, whether or not it\'s a constant expression.\nstatic bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, ConstantExprKind Kind, CheckedTemporaries &CheckedTemps) {\n  // Additional restrictions apply in a template argument. We only enforce the\n  // C++20 restrictions here; additional syntactic and semantic restrictions\n  // are applied elsewhere.\n  if (isTemplateArgument(Kind)) {\n    if (InvalidBaseKind != -1) {\n      Info.FFDiag(Loc, diag::note_constexpr_invalid_template_arg) << IsReferenceType << !Designator.Entries.empty() << InvalidBaseKind << Ident;"},{P,5082,"/// EvaluateConvertedConstantExpression - Evaluate an Expression\n/// That is a converted constant expression\n/// (which was built with BuildConvertedConstantExpression)\nstatic ExprResult EvaluateConvertedConstantExpression(Sema &S, Expr *E, QualType T, APValue &Value, Sema::CCEKind CCE, bool RequireInt, const APValue &PreNarrowingValue) {\n  } else if (!Notes.empty() && Notes[0].second.getDiagID() == diag::note_constexpr_invalid_template_arg) {"}}

[n]={{p,7983,"bool PointerExprEvaluator::VisitCastExpr(const CastExpr *E) {\n  case CK_AddressSpaceConversion:\n    // Bitcasts to cv void* are static_casts, not reinterpret_casts, so are\n    // permitted in constant expressions in C++11. Bitcasts from cv void* are\n    // also static_casts, but we disallow them as a resolution to DR1312.\n    if (!E->getType()->isVoidPointerType()) {\n      // 1. We\'ll allow it in std::allocator::allocate, and anything which that\n      //    calls.\n      // 2. HACK 2022-03-28: Work around an issue with libstdc++\'s\n      //    <source_location> header. Fixed in GCC 12 and later (2022-04-??).\n      //    We\'ll allow it in the body of std::source_location::current.  GCC\'s\n      //    implementation had a parameter of type `void*`, and casts from\n      //    that back to `const __impl*` in its body.\n      if (VoidPtrCastMaybeOK && (Info.getStdAllocatorCaller(\"allocate\") || IsDeclSourceLocationCurrent(Info.CurrentCall->Callee) || Info.getLangOpts().CPlusPlus26)) {\n      } else {\n        if (SubExpr->getType()->isVoidPointerType()) {\n          if (HasValidResult)\n            CCEDiag(E, diag::note_constexpr_invalid_void_star_cast) << SubExpr->getType() << Info.getLangOpts().CPlusPlus26 << Result.Designator.getType(Info.Ctx).getCanonicalType() << E->getType()->getPointeeType();"}}

[n]={{p,2478,"/// Perform the given binary integer operation.\nstatic bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result) {\n  shift_left:\n    if (SA != RHS) {\n      Info.CCEDiag(E, diag::note_constexpr_large_shift) << RHS << E->getType() << LHS.getBitWidth();"},{p,2508,"/// Perform the given binary integer operation.\nstatic bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result) {\n  shift_right:\n    if (SA != RHS)\n      Info.CCEDiag(E, diag::note_constexpr_large_shift) << RHS << E->getType() << LHS.getBitWidth();"},{p,12525,"bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {\n  case BO_Shr: {\n    // Embedded-C 4.1.6.2.2:\n    //  The right operand must be nonnegative and less than the total number\n    //  of (nonpadding) bits of the fixed-point operand ...\n    if (RHSVal.isNegative())\n    else if (Amt != RHSVal)\n      Info.CCEDiag(E, diag::note_constexpr_large_shift) << RHSVal << E->getType() << ShiftBW;"}}

[n]={{p,3541,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (LVal.getLValueCallIndex()) {\n    if (!Frame) {\n      Info.FFDiag(E, diag::note_constexpr_lifetime_ended, 1) << AK << LVal.Base.is<const ValueDecl *>();"},{w,157,"bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  if (!Ptr.isLive()) {\n    S.FFDiag(Src, diag::note_constexpr_lifetime_ended, 1) << AK << !IsTemp;"}}

[n]={{p,11660,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isPointerType() && RHSTy->isPointerType()) {\n    // Reject differing bases from the normal codepath; we special-case\n    // comparisons to null.\n    if (!HasSameBase(LHSValue, RHSValue)) {\n      // It\'s implementation-defined whether distinct literals will have\n      // distinct addresses. In clang, the result of such a comparison is\n      // unspecified, so it is not a constant expression. However, we do know\n      // that the address of a literal will be non-null.\n      if ((IsLiteralLValue(LHSValue) || IsLiteralLValue(RHSValue)) && LHSValue.Base && RHSValue.Base)\n        return DiagComparison(diag::note_constexpr_literal_comparison);"}}

[n]={{p,2487,"/// Perform the given binary integer operation.\nstatic bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result) {\n  shift_left:\n    if (SA != RHS) {\n    } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {\n      // C++11 [expr.shift]p2: A signed left shift must have a non-negative\n      // operand, and must not overflow the corresponding unsigned type.\n      // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to\n      // E1 x 2^E2 module 2^N.\n      if (LHS.isNegative())\n      else if (LHS.countl_zero() < SA)\n        Info.CCEDiag(E, diag::note_constexpr_lshift_discards);"}}

[n]={{p,2485,"/// Perform the given binary integer operation.\nstatic bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result) {\n  shift_left:\n    if (SA != RHS) {\n    } else if (LHS.isSigned() && !Info.getLangOpts().CPlusPlus20) {\n      // C++11 [expr.shift]p2: A signed left shift must have a non-negative\n      // operand, and must not overflow the corresponding unsigned type.\n      // C++2a [expr.shift]p2: E1 << E2 is the unique value congruent to\n      // E1 x 2^E2 module 2^N.\n      if (LHS.isNegative())\n        Info.CCEDiag(E, diag::note_constexpr_lshift_of_negative) << LHS;"}}

[n]={{p,8305,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemchr: {\n    // Pointers to const void may point to objects of incomplete type.\n    if (IsRawByte && CharTy->isIncompleteType()) {\n      Info.FFDiag(E, diag::note_constexpr_ltor_incomplete_type) << CharTy;"}}

[n]={{p,3644,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Unless we\'re looking at a local variable or argument in a constexpr call,\n    // the variable we\'re reading must be const.\n    if (!Frame) {\n      if (IsAccess && isa<ParmVarDecl>(VD)) {\n      } else if (Info.getLangOpts().CPlusPlus14 && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n      } else if (isModification(AK)) {\n      } else if (VD->isConstexpr()) {\n      } else if (BaseType->isIntegralOrEnumerationType()) {\n        if (!IsConstant) {\n          if (Info.getLangOpts().CPlusPlus) {\n            Info.FFDiag(E, diag::note_constexpr_ltor_non_const_int, 1) << VD;"}}

[n]={{p,2946,"/// Try to evaluate the initializer for a variable declaration.\n///\n/// \\param Info  Information about the ongoing evaluation.\n/// \\param E      An expression to be used when printing diagnostics.\n/// \\param VD    The variable whose initializer should be obtained.\n/// \\param Version The version of the variable within the frame.\n/// \\param Frame  The frame in which the variable was created. Must be null\n///              if this variable is not local to the evaluation.\n/// \\param Result Filled in with a pointer to the value of the variable.\nstatic bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, const VarDecl *VD, CallStackFrame *Frame, unsigned Version, APValue *&Result) {\n  if (Init->isValueDependent()) {\n    if (!Info.checkingPotentialConstantExpression()) {\n      Info.FFDiag(E, Info.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr : diag::note_constexpr_ltor_non_integral, 1) << VD << VD->getType();"},{p,3660,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Unless we\'re looking at a local variable or argument in a constexpr call,\n    // the variable we\'re reading must be const.\n    if (!Frame) {\n      if (IsAccess && isa<ParmVarDecl>(VD)) {\n      } else if (Info.getLangOpts().CPlusPlus14 && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n      } else if (isModification(AK)) {\n      } else if (VD->isConstexpr()) {\n      } else if (BaseType->isIntegralOrEnumerationType()) {\n      } else if (!IsAccess) {\n      } else if (IsConstant && Info.checkingPotentialConstantExpression() && BaseType->isLiteralType(Info.Ctx) && !VD->hasDefinition()) {\n      } else if (IsConstant) {\n        // Keep evaluating to see what we can do. In particular, we support\n        // folding of const floating-point types, in order to make static const\n        // data members of such types (supported as an extension) more useful.\n        if (Info.getLangOpts().CPlusPlus) {\n          Info.CCEDiag(E, Info.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr : diag::note_constexpr_ltor_non_integral, 1) << VD << BaseType;"},{p,3668,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Unless we\'re looking at a local variable or argument in a constexpr call,\n    // the variable we\'re reading must be const.\n    if (!Frame) {\n      if (IsAccess && isa<ParmVarDecl>(VD)) {\n      } else if (Info.getLangOpts().CPlusPlus14 && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n      } else if (isModification(AK)) {\n      } else if (VD->isConstexpr()) {\n      } else if (BaseType->isIntegralOrEnumerationType()) {\n      } else if (!IsAccess) {\n      } else if (IsConstant && Info.checkingPotentialConstantExpression() && BaseType->isLiteralType(Info.Ctx) && !VD->hasDefinition()) {\n      } else if (IsConstant) {\n      } else {\n        // Never allow reading a non-const value.\n        if (Info.getLangOpts().CPlusPlus) {\n          Info.FFDiag(E, Info.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr : diag::note_constexpr_ltor_non_integral, 1) << VD << BaseType;"},{w,127,"bool CheckExtern(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {\n  if (!S.checkingPotentialConstantExpression()) {\n    S.FFDiag(Loc, diag::note_constexpr_ltor_non_constexpr, 1) << VD;"}}

[n]={{p,2946,"/// Try to evaluate the initializer for a variable declaration.\n///\n/// \\param Info  Information about the ongoing evaluation.\n/// \\param E      An expression to be used when printing diagnostics.\n/// \\param VD    The variable whose initializer should be obtained.\n/// \\param Version The version of the variable within the frame.\n/// \\param Frame  The frame in which the variable was created. Must be null\n///              if this variable is not local to the evaluation.\n/// \\param Result Filled in with a pointer to the value of the variable.\nstatic bool evaluateVarDeclInit(EvalInfo &Info, const Expr *E, const VarDecl *VD, CallStackFrame *Frame, unsigned Version, APValue *&Result) {\n  if (Init->isValueDependent()) {\n    if (!Info.checkingPotentialConstantExpression()) {\n      Info.FFDiag(E, Info.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr : diag::note_constexpr_ltor_non_integral, 1) << VD << VD->getType();"},{p,3660,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Unless we\'re looking at a local variable or argument in a constexpr call,\n    // the variable we\'re reading must be const.\n    if (!Frame) {\n      if (IsAccess && isa<ParmVarDecl>(VD)) {\n      } else if (Info.getLangOpts().CPlusPlus14 && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n      } else if (isModification(AK)) {\n      } else if (VD->isConstexpr()) {\n      } else if (BaseType->isIntegralOrEnumerationType()) {\n      } else if (!IsAccess) {\n      } else if (IsConstant && Info.checkingPotentialConstantExpression() && BaseType->isLiteralType(Info.Ctx) && !VD->hasDefinition()) {\n      } else if (IsConstant) {\n        // Keep evaluating to see what we can do. In particular, we support\n        // folding of const floating-point types, in order to make static const\n        // data members of such types (supported as an extension) more useful.\n        if (Info.getLangOpts().CPlusPlus) {\n          Info.CCEDiag(E, Info.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr : diag::note_constexpr_ltor_non_integral, 1) << VD << BaseType;"},{p,3668,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Unless we\'re looking at a local variable or argument in a constexpr call,\n    // the variable we\'re reading must be const.\n    if (!Frame) {\n      if (IsAccess && isa<ParmVarDecl>(VD)) {\n      } else if (Info.getLangOpts().CPlusPlus14 && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n      } else if (isModification(AK)) {\n      } else if (VD->isConstexpr()) {\n      } else if (BaseType->isIntegralOrEnumerationType()) {\n      } else if (!IsAccess) {\n      } else if (IsConstant && Info.checkingPotentialConstantExpression() && BaseType->isLiteralType(Info.Ctx) && !VD->hasDefinition()) {\n      } else if (IsConstant) {\n      } else {\n        // Never allow reading a non-const value.\n        if (Info.getLangOpts().CPlusPlus) {\n          Info.FFDiag(E, Info.getLangOpts().CPlusPlus11 ? diag::note_constexpr_ltor_non_constexpr : diag::note_constexpr_ltor_non_integral, 1) << VD << BaseType;"},{p,7444,"bool LValueExprEvaluator::VisitVarDecl(const Expr *E, const VarDecl *VD) {\n  if (!Info.getLangOpts().CPlusPlus11) {\n    Info.CCEDiag(E, diag::note_constexpr_ltor_non_integral, 1) << VD << VD->getType();"}}

[n]={{p,11771,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isMemberPointerType()) {\n    // If either operand is a pointer to a weak function, the comparison is not\n    // constant.\n    if (LHSValue.getDecl() && LHSValue.getDecl()->isWeak()) {\n      Info.FFDiag(E, diag::note_constexpr_mem_pointer_weak_comparison) << LHSValue.getDecl();"},{p,11775,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isMemberPointerType()) {\n    if (RHSValue.getDecl() && RHSValue.getDecl()->isWeak()) {\n      Info.FFDiag(E, diag::note_constexpr_mem_pointer_weak_comparison) << RHSValue.getDecl();"}}

[n]={{p,8311,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemchr: {\n    // Give up on byte-oriented matching against multibyte elements.\n    // FIXME: We can compare the bytes in the correct order.\n    if (IsRawByte && !isOneByteCharacterType(CharTy)) {\n      Info.FFDiag(E, diag::note_constexpr_memchr_unsupported) << (\"\'\" + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + \"\'\").str() << CharTy;"}}

[n]={{p,11018,"bool IntExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemcmp: {\n    // For memcmp, allow comparing any arrays of \'[[un]signed] char\' or\n    // \'char8_t\', but no other types.\n    if (IsRawByte && !(isOneByteCharacterType(CharTy1) && isOneByteCharacterType(CharTy2))) {\n      Info.FFDiag(E, diag::note_constexpr_memcmp_unsupported) << (\"\'\" + Info.Ctx.BuiltinInfo.getName(BuiltinOp) + \"\'\").str() << CharTy1 << CharTy2;"}}

[n]={{p,8420,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (T->isIncompleteType()) {\n      Info.FFDiag(E, diag::note_constexpr_memcpy_incomplete_type) << Move << T;"}}

[n]={{p,8424,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (!T.isTriviallyCopyableType(Info.Ctx)) {\n      Info.FFDiag(E, diag::note_constexpr_memcpy_nontrivial) << Move << T;"}}

[n]={{p,8403,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    // Otherwise, if either of the operands is null, we can\'t proceed. Don\'t\n    // try to determine the type of the copied objects, because there aren\'t\n    // any.\n    if (!Src.Base || !Dest.Base) {\n      Info.FFDiag(E, diag::note_constexpr_memcpy_null) << Move << WChar << !!Src.Base << Val.getAsString(Info.Ctx, E->getArg(0)->getType());"}}

[n]={{p,8460,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (HasSameBase(Src, Dest)) {\n      if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) {\n        // Dest is inside the source region.\n        if (!Move) {\n          Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;"},{p,8469,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (HasSameBase(Src, Dest)) {\n      if (DestOffset >= SrcOffset && DestOffset - SrcOffset < NBytes) {\n      } else if (!Move && SrcOffset >= DestOffset && SrcOffset - DestOffset < NBytes) {\n        Info.FFDiag(E, diag::note_constexpr_memcpy_overlap) << WChar;"}}

[n]={{p,8416,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (!Info.Ctx.hasSameUnqualifiedType(T, SrcT)) {\n      Info.FFDiag(E, diag::note_constexpr_memcpy_type_pun) << Move << SrcT << T;"}}

[n]={{p,8435,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (!WChar) {\n      if (Remainder) {\n        Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported) << Move << WChar << 0 << T << toString(OrigN, 10, /*Signed*/ false) << (unsigned)TSize;"},{p,8446,"bool PointerExprEvaluator::VisitBuiltinCallExpr(const CallExpr *E, unsigned BuiltinOp) {\n  case Builtin::BI__builtin_wmemmove: {\n    if (N.ugt(RemainingSrcSize) || N.ugt(RemainingDestSize)) {\n      Info.FFDiag(E, diag::note_constexpr_memcpy_unsupported) << Move << WChar << (N.ugt(RemainingSrcSize) ? 1 : 2) << T << toString(N, 10, /*Signed*/ false);"}}

[n]={{p,2181,"/// Enforce C++2a [expr.const]/4.17, which disallows new-expressions unless\n/// \"the allocated storage is deallocated within the evaluation\".\nstatic bool CheckMemoryLeaks(EvalInfo &Info) {\n  if (!Info.HeapAllocs.empty()) {\n    Info.CCEDiag(Info.HeapAllocs.begin()->second.AllocExpr, diag::note_constexpr_memory_leak) << unsigned(Info.HeapAllocs.size() - 1);"}}

[n]={{p,3431,"struct ModifySubobjectHandler {\n  bool checkConst(QualType QT) {\n    // Assigning to a const object has undefined behavior.\n    if (QT.isConstQualified()) {\n      Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;"},{p,3877,"struct CompoundAssignSubobjectHandler {\n  bool checkConst(QualType QT) {\n    // Assigning to a const object has undefined behavior.\n    if (QT.isConstQualified()) {\n      Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;"},{p,4000,"struct IncDecSubobjectHandler {\n  bool checkConst(QualType QT) {\n    // Assigning to a const object has undefined behavior.\n    if (QT.isConstQualified()) {\n      Info.FFDiag(E, diag::note_constexpr_modify_const_type) << QT;"},{w,207,"bool CheckConst(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {\n  S.FFDiag(Loc, diag::note_constexpr_modify_const_type) << Ty;"}}

[n]={{p,3574,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Allow reading from a GUID declaration.\n    if (auto *GD = dyn_cast<MSGuidDecl>(D)) {\n      if (isModification(AK)) {\n        Info.FFDiag(E, diag::note_constexpr_modify_global);"},{p,3588,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Allow reading the APValue from an UnnamedGlobalConstantDecl.\n    if (auto *GCD = dyn_cast<UnnamedGlobalConstantDecl>(D)) {\n      if (isModification(AK)) {\n        Info.FFDiag(E, diag::note_constexpr_modify_global);"},{p,3597,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Allow reading from template parameter objects.\n    if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(D)) {\n      if (isModification(AK)) {\n        Info.FFDiag(E, diag::note_constexpr_modify_global);"},{p,3635,"/// Find the complete object to which an LValue refers.\nstatic CompleteObject findCompleteObject(EvalInfo &Info, const Expr *E, AccessKinds AK, const LValue &LVal, QualType LValType) {\n  if (Info.getLangOpts().CPlusPlus14 && LVal.Base == Info.EvaluatingDecl && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n  } else if (const ValueDecl *D = LVal.Base.dyn_cast<const ValueDecl *>()) {\n    // Unless we\'re looking at a local variable or argument in a constexpr call,\n    // the variable we\'re reading must be const.\n    if (!Frame) {\n      if (IsAccess && isa<ParmVarDecl>(VD)) {\n      } else if (Info.getLangOpts().CPlusPlus14 && lifetimeStartedInEvaluation(Info, LVal.Base)) {\n      } else if (isModification(AK)) {\n        Info.FFDiag(E, diag::note_constexpr_modify_global);"},{w,111,"static bool CheckGlobal(InterpState &S, CodePtr OpPC, const Pointer &Ptr) {\n  if (auto ID = Ptr.getDeclID()) {\n    S.FFDiag(S.Current->getLocation(OpPC), diag::note_constexpr_modify_global);"}}

[n]={{p,2469,"/// Perform the given binary integer operation.\nstatic bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result) {\n  case BO_Shl: {\n    if (Info.getLangOpts().OpenCL)\n    else if (RHS.isSigned() && RHS.isNegative()) {\n      Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;"},{p,2499,"/// Perform the given binary integer operation.\nstatic bool handleIntIntBinOp(EvalInfo &Info, const Expr *E, const APSInt &LHS, BinaryOperatorKind Opcode, APSInt RHS, APSInt &Result) {\n  case BO_Shr: {\n    if (Info.getLangOpts().OpenCL)\n    else if (RHS.isSigned() && RHS.isNegative()) {\n      Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHS;"},{p,12523,"bool FixedPointExprEvaluator::VisitBinaryOperator(const BinaryOperator *E) {\n  case BO_Shr: {\n    // Embedded-C 4.1.6.2.2:\n    //  The right operand must be nonnegative and less than the total number\n    //  of (nonpadding) bits of the fixed-point operand ...\n    if (RHSVal.isNegative())\n      Info.CCEDiag(E, diag::note_constexpr_negative_shift) << RHSVal;"}}

[n]={{p,5982,"/// Perform a call to \'perator new\' or to `__builtin_operator_new\'.\nstatic bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E, LValue &Result) {\n  if (!Caller) {\n    Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus20 ? diag::note_constexpr_new_untyped : diag::note_constexpr_new);"},{p,8499,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (!Info.getLangOpts().CPlusPlus20)\n    Info.CCEDiag(E, diag::note_constexpr_new);"},{p,13427,"bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {\n  // Deleting a null pointer has no effect.\n  if (Pointer.isNullPointer()) {\n    // This is the only case where we need to produce an extension warning:\n    // the only other way we can succeed is if we find a dynamic allocation,\n    // and we will have warned when we allocated it in that case.\n    if (!Info.getLangOpts().CPlusPlus20)\n      Info.CCEDiag(E, diag::note_constexpr_new);"}}

[n]={{p,6068,"/// Check that the given object is a suitable pointer to a heap allocation that\n/// still exists and is of the right kind for the purpose of a deletion.\n///\n/// On success, returns the heap allocation to deallocate. On failure, produces\n/// a diagnostic and returns std::nullopt.\nstatic std::optional<DynAlloc *> CheckDeleteKind(EvalInfo &Info, const Expr *E, const LValue &Pointer, DynAlloc::Kind DeallocKind) {\n  if (DeallocKind != (*Alloc)->getKind()) {\n    Info.FFDiag(E, diag::note_constexpr_new_delete_mismatch) << DeallocKind << (*Alloc)->getKind() << AllocType;"}}

[n]={{p,8564,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (std::optional<const Expr *> ArraySize = E->getArraySize()) {\n    // C++ [expr.new]p9:\n    //  The expression is erroneous if:\n    //  -- [...] its value before converting to size_t [or] applying the\n    //      second standard conversion sequence is less than zero\n    if (ArrayBound.isSigned() && ArrayBound.isNegative()) {\n      Info.FFDiag(*ArraySize, diag::note_constexpr_new_negative) << ArrayBound << (*ArraySize)->getSourceRange();"}}

[n]={{p,8518,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (OperatorNew->isReservedGlobalPlacementOperator() && Info.CurrentCall->isStdFunction() && !E->isArray()) {\n  } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {\n    Info.FFDiag(E, diag::note_constexpr_new_non_replaceable) << isa<CXXMethodDecl>(OperatorNew) << OperatorNew;"},{p,13409,"bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {\n  if (!OperatorDelete->isReplaceableGlobalAllocationFunction()) {\n    Info.FFDiag(E, diag::note_constexpr_new_non_replaceable) << isa<CXXMethodDecl>(OperatorDelete) << OperatorDelete;"},{p,13448,"bool VoidExprEvaluator::VisitCXXDeleteExpr(const CXXDeleteExpr *E) {\n  // For a class type with a virtual destructor, the selected operator delete\n  // is the one looked up when building the destructor.\n  if (!E->isArrayForm() && !E->isGlobalDelete()) {\n    if (VirtualDelete && !VirtualDelete->isReplaceableGlobalAllocationFunction()) {\n      Info.FFDiag(E, diag::note_constexpr_new_non_replaceable) << isa<CXXMethodDecl>(VirtualDelete) << VirtualDelete;"}}

[n]={{p,5988,"/// Perform a call to \'perator new\' or to `__builtin_operator_new\'.\nstatic bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E, LValue &Result) {\n  if (ElemType->isIncompleteType() || ElemType->isFunctionType()) {\n    Info.FFDiag(E->getExprLoc(), diag::note_constexpr_new_not_complete_object_type) << (ElemType->isIncompleteType() ? 0 : 1) << ElemType;"}}

[n]={{p,8532,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (OperatorNew->isReservedGlobalPlacementOperator() && Info.CurrentCall->isStdFunction() && !E->isArray()) {\n  } else if (!OperatorNew->isReplaceableGlobalAllocationFunction()) {\n  } else if (E->getNumPlacementArgs()) {\n    // The only new-placement list we support is of the form (std::nothrow).\n    //\n    // FIXME: There is no restriction on this, but it\'s not clear that any\n    // other form makes any sense. We get here for cases such as:\n    //\n    //  new (std::align_val_t{N}) X(int)\n    //\n    // (which should presumably be valid only if N is a multiple of\n    // alignof(int), and in any case can\'t be deallocated unless N is\n    // alignof(X) and X has new-extended alignment).\n    if (E->getNumPlacementArgs() != 1 || !E->getPlacementArg(0)->getType()->isNothrowT())\n      return Error(E, diag::note_constexpr_new_placement);"}}

[n]={{p,6019,"/// Perform a call to \'perator new\' or to `__builtin_operator_new\'.\nstatic bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E, LValue &Result) {\n  if (ByteSize.getActiveBits() > ConstantArrayType::getMaxSizeBits(Info.Ctx)) {\n    Info.FFDiag(E, diag::note_constexpr_new_too_large) << APSInt(Size, true);"},{p,8574,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (std::optional<const Expr *> ArraySize = E->getArraySize()) {\n    //  -- its value is such that the size of the allocated object would\n    //      exceed the implementation-defined limit\n    if (ConstantArrayType::getNumAddressingBits(Info.Ctx, AllocType, ArrayBound) > ConstantArrayType::getMaxSizeBits(Info.Ctx)) {\n      Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_large) << ArrayBound << (*ArraySize)->getSourceRange();"}}

[n]={{p,8598,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (std::optional<const Expr *> ArraySize = E->getArraySize()) {\n    //  -- the new-initializer is a braced-init-list and the number of\n    //      array elements for which initializers are provided [...]\n    //      exceeds the number of elements to initialize\n    if (!Init) {\n    } else if (isa<CXXScalarValueInitExpr>(Init) || isa<ImplicitValueInitExpr>(Init)) {\n    } else if (auto *CCE = dyn_cast<CXXConstructExpr>(Init)) {\n    } else {\n      if (InitBound.ugt(AllocBound)) {\n        Info.FFDiag(*ArraySize, diag::note_constexpr_new_too_small) << toString(AllocBound, 10, /*Signed=*/false) << toString(InitBound, 10, /*Signed=*/false) << (*ArraySize)->getSourceRange();"}}

[n]={{p,5982,"/// Perform a call to \'perator new\' or to `__builtin_operator_new\'.\nstatic bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E, LValue &Result) {\n  if (!Caller) {\n    Info.FFDiag(E->getExprLoc(), Info.getLangOpts().CPlusPlus20 ? diag::note_constexpr_new_untyped : diag::note_constexpr_new);"}}

[n]={{p,5573,"/// Evaluate a function call.\nstatic bool HandleFunctionCall(SourceLocation CallLoc, const FunctionDecl *Callee, const LValue *This, const Expr *E, ArrayRef<const Expr *> Args, CallRef Call, const Stmt *Body, EvalInfo &Info, APValue &Result, const LValue *ResultSlot) {\n  if (ESR == ESR_Succeeded) {\n    Info.FFDiag(Callee->getEndLoc(), diag::note_constexpr_no_return);"}}

[n]={{p,1941,"/// Check that this reference or pointer core constant expression is a valid\n/// value for an address or reference constant expression. Return true if we\n/// can fold this expression, whether or not it\'s a constant expression.\nstatic bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, ConstantExprKind Kind, CheckedTemporaries &CheckedTemps) {\n  // Check that the object is a global. Note that the fake \'this\' object we\n  // manufacture when checking potential constant expressions is conservatively\n  // assumed to be global here.\n  if (!IsGlobalLValue(Base)) {\n    if (Info.getLangOpts().CPlusPlus11) {\n      Info.FFDiag(Loc, diag::note_constexpr_non_global, 1) << IsReferenceType << !Designator.Entries.empty() << !!BaseVD << BaseVD;"}}

[n]={{p,2078,"/// Check that this core constant expression is of literal type, and if not,\n/// produce an appropriate diagnostic.\nstatic bool CheckLiteralType(EvalInfo &Info, const Expr *E, const LValue *This = nullptr) {\n  // Prvalue constant expressions must be of literal types.\n  if (Info.getLangOpts().CPlusPlus11)\n    Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();"},{p,4139,"/// Build an lvalue for the object argument of a member function call.\nstatic bool EvaluateObjectArgument(EvalInfo &Info, const Expr *Object, LValue &This) {\n  Info.FFDiag(Object, diag::note_constexpr_nonliteral) << Object->getType();"},{p,13532,"static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {\n  if (E->isGLValue() || T->isFunctionType()) {\n  } else if (T->isVectorType()) {\n  } else if (T->isIntegralOrEnumerationType()) {\n  } else if (T->hasPointerRepresentation()) {\n  } else if (T->isRealFloatingType()) {\n  } else if (T->isAnyComplexType()) {\n  } else if (T->isFixedPointType()) {\n  } else if (T->isMemberPointerType()) {\n  } else if (T->isArrayType()) {\n  } else if (T->isRecordType()) {\n  } else if (T->isVoidType()) {\n    if (!Info.getLangOpts().CPlusPlus11)\n      Info.CCEDiag(E, diag::note_constexpr_nonliteral) << E->getType();"},{p,13548,"static bool Evaluate(APValue &Result, EvalInfo &Info, const Expr *E) {\n  if (E->isGLValue() || T->isFunctionType()) {\n  } else if (T->isVectorType()) {\n  } else if (T->isIntegralOrEnumerationType()) {\n  } else if (T->hasPointerRepresentation()) {\n  } else if (T->isRealFloatingType()) {\n  } else if (T->isAnyComplexType()) {\n  } else if (T->isFixedPointType()) {\n  } else if (T->isMemberPointerType()) {\n  } else if (T->isArrayType()) {\n  } else if (T->isRecordType()) {\n  } else if (T->isVoidType()) {\n  } else if (T->isAtomicType()) {\n  } else if (Info.getLangOpts().CPlusPlus11) {\n    Info.FFDiag(E, diag::note_constexpr_nonliteral) << E->getType();"}}

[n]={{p,1949,"/// Check that this reference or pointer core constant expression is a valid\n/// value for an address or reference constant expression. Return true if we\n/// can fold this expression, whether or not it\'s a constant expression.\nstatic bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, ConstantExprKind Kind, CheckedTemporaries &CheckedTemps) {\n  // Check that the object is a global. Note that the fake \'this\' object we\n  // manufacture when checking potential constant expressions is conservatively\n  // assumed to be global here.\n  if (!IsGlobalLValue(Base)) {\n    if (Info.getLangOpts().CPlusPlus11) {\n      if (VarD && VarD->isConstexpr()) {\n        Info.Note(VarD->getLocation(), diag::note_constexpr_not_static) << VarD << FixItHint::CreateInsertion(VarD->getBeginLoc(), \"static \");"}}

[n]={{p,6863,"template <class Derived> class ExprEvaluatorBase : public ConstStmtVisitor<Derived, bool> {\n  bool handleCallExpr(const CallExpr *E, APValue &Result, const LValue *ResultSlot) {\n    // Extract function decl and \'this\' pointer from the callee.\n    if (CalleeType->isSpecificBuiltinType(BuiltinType::BoundMember)) {\n    } else if (CalleeType->isFunctionPointerType()) {\n      if (CalleeLV.isNullPointer()) {\n        Info.FFDiag(Callee, diag::note_constexpr_null_callee) << const_cast<Expr *>(Callee);"}}

[n]={{p,1448,"#endif\n  bool checkNullPointer(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {\n    return checkNullPointerDiagnosingWith([&Info, E, CSK] { Info.CCEDiag(E, diag::note_constexpr_null_subobject) << CSK; });"},{w,146,"bool CheckLive(InterpState &S, CodePtr OpPC, const Pointer &Ptr, AccessKinds AK) {\n  if (Ptr.isZero()) {\n    if (Ptr.isField())\n      S.FFDiag(Src, diag::note_constexpr_null_subobject) << CSK_Field;"},{w,174,"bool CheckNull(InterpState &S, CodePtr OpPC, const Pointer &Ptr, CheckSubobjectKind CSK) {\n  S.FFDiag(Loc, diag::note_constexpr_null_subobject) << CSK;"}}

[n]={{p,6009,"/// Perform a call to \'perator new\' or to `__builtin_operator_new\'.\nstatic bool HandleOperatorNewCall(EvalInfo &Info, const CallExpr *E, LValue &Result) {\n  if (Remainder != 0) {\n    Info.FFDiag(E->getExprLoc(), diag::note_constexpr_operator_new_bad_size) << ByteSize << APSInt(ElemSizeAP, true) << ElemType;"}}

[n]={{p,2252,"template <typename T> static bool HandleOverflow(EvalInfo &Info, const Expr *E, const T &SrcValue, QualType DestType) {\n  Info.CCEDiag(E, diag::note_constexpr_overflow) << SrcValue << DestType;"},{"clang/lib/AST/Interp/InterpState.cpp",42,"bool InterpState::reportOverflow(const Expr *E, const llvm::APSInt &Value) {\n  CCEDiag(E, diag::note_constexpr_overflow) << Value << Type;"}}

[n]={{p,2032,"/// Check that this reference or pointer core constant expression is a valid\n/// value for an address or reference constant expression. Return true if we\n/// can fold this expression, whether or not it\'s a constant expression.\nstatic bool CheckLValueConstantExpression(EvalInfo &Info, SourceLocation Loc, QualType Type, const LValue &LVal, ConstantExprKind Kind, CheckedTemporaries &CheckedTemps) {\n  // Does this refer one past the end of some object?\n  if (!Designator.Invalid && Designator.isOnePastTheEnd()) {\n    Info.FFDiag(Loc, diag::note_constexpr_past_end, 1) << !Designator.Entries.empty() << !!BaseVD << BaseVD;"}}

[n]={{p,1238,"bool SubobjectDesignator::checkSubobject(EvalInfo &Info, const Expr *E, CheckSubobjectKind CSK) {\n  if (isOnePastTheEnd()) {\n    Info.CCEDiag(E, diag::note_constexpr_past_end_subobject) << CSK;"},{w,190,"bool CheckRange(InterpState &S, CodePtr OpPC, const Pointer &Ptr, CheckSubobjectKind CSK) {\n  S.FFDiag(Loc, diag::note_constexpr_past_end_subobject) << CSK;"}}

[n]={{p,8629,"bool PointerExprEvaluator::VisitCXXNewExpr(const CXXNewExpr *E) {\n  if (IsPlacement) {\n    struct FindObjectHandler {\n      bool found(APValue &Subobj, QualType SubobjType) {\n        // FIXME: Reject the cases where [basic.life]p8 would not permit the\n        // old name of the object to be used to name the new object.\n        if (!Info.Ctx.hasSameUnqualifiedType(SubobjType, AllocType)) {\n          Info.FFDiag(E, diag::note_constexpr_placement_new_wrong_type) << SubobjType << AllocType;"}}

[n]={{p,11715,"template <class SuccessCB, class AfterCB> static bool EvaluateComparisonBinaryOperator(EvalInfo &Info, const BinaryOperator *E, SuccessCB &&Success, AfterCB &&DoAfter) {\n  if (LHSTy->isPointerType() && RHSTy->isPointerType()) {\n    // C++11 [expr.rel]p2:\n    // - If two pointers point to non-static data members of the same object,\n    //  or to subobjects or array elements fo such members, recursively, the\n    //  pointer to the later declared member compares greater provided the\n    //  two members have the same access control and provided their class is\n    //  not a union.\n    //  [...]\n    // - Otherwise pointer comparisons are unspecified.\n    if (!LHSDesignator.Invalid && !RHSDesignator.Invalid && IsRelational) {\n      // At the point where the designators diverge, the comparison has a\n      // specified value if:\n      //  - we are comparing array indices\n      //  - we are comparing fields of a union, or fields with the same access\n      // Otherwise, the result is unspecified and thus the comparison is not a\n      // constant expression.\n      if (!WasArrayIndex && Mismatch < LHSDesignator.Entries.size() && Mismatch < RHSDesignator.Entries.size()) {\n        if (!LF && !RF)\n          Info.CCEDiag(E, diag::note_constexpr_pointer_comparison_base_classes);"}}