Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaDeclCXX_8cpp_source.html below:

clang: lib/Sema/SemaDeclCXX.cpp Source File

;

CheckDefaultArgumentVisitor

*DefaultArg;

CheckDefaultArgumentVisitor(

&S,

*DefaultArg)

: S(S), DefaultArg(DefaultArg) {}

VisitLambdaExpr(

*Lambda);

CheckDefaultArgumentVisitor::VisitExpr(

*

) {

IsInvalid =

;

(

*SubStmt :

->children())

IsInvalid |= Visit(SubStmt);

CheckDefaultArgumentVisitor::VisitDeclRefExpr(

*DRE) {

(!isa<VarDecl, BindingDecl>(

))

(

*Param = dyn_cast<ParmVarDecl>(

)) {

diag::err_param_default_argument_references_param)

<< Param->getDeclName() << DefaultArg->getSourceRange();

}

(

*VD =

->getPotentiallyDecomposedVarDecl()) {

diag::err_param_default_argument_references_local)

CheckDefaultArgumentVisitor::VisitCXXThisExpr(

*ThisE) {

diag::err_param_default_argument_references_this)

CheckDefaultArgumentVisitor::VisitPseudoObjectExpr(

(

*OVE = dyn_cast<OpaqueValueExpr>(

)) {

= OVE->getSourceExpr();

assert(

&&

);

CheckDefaultArgumentVisitor::VisitLambdaExpr(

*Lambda) {

S.

(LC.getLocation(), diag::err_lambda_capture_default_arg);

*

= cast<VarDecl>(LC.getCapturedVar());

(!Method || ComputedEST ==

)

llvm_unreachable(

);

);

assert(EST ==

&&

);

);

Exceptions.push_back(

);

(

->canThrow(S))

diag::err_typecheck_decl_incomplete_type))

CheckCompletedExpr(Arg, EqualLoc);

UnparsedDefaultArgInstantiationsMap::iterator InstPos

(

I = 0, N = InstPos->second.size(); I != N; ++I)

InstPos->second[I]->setUninstantiatedDefaultArg(Arg);

(!param || !DefaultArg)

(EqualLoc, diag::err_param_default_argument)

(EqualLoc, diag::err_param_default_argument_on_parameter_pack)

CheckDefaultArgumentVisitor DefaultArgChecker(*

, DefaultArg);

(DefaultArgChecker.Visit(DefaultArg))

Param->

().getNonReferenceType());

MightBeFunction =

.isFunctionDeclarationContext();

(

i = 0, e =

.getNumTypeObjects(); i != e; ++i) {

(MightBeFunction) {

MightBeFunction =

;

(

argIdx = 0, e = chunk.

.

; argIdx != e;

std::unique_ptr<CachedTokens> Toks =

(Toks->size() > 1)

Toks->back().getLocation());

(Param->

(), diag::err_param_default_argument_nonfunc)

(Param->

(), diag::err_param_default_argument_nonfunc)

MightBeFunction =

;

return P->hasDefaultArg() && !P->hasInheritedDefaultArg();

(

; PrevForDefaultArgs;

(

p = 0, NumParams = PrevForDefaultArgs

p < NumParams; ++p) {

OldParamHasDfl = OldParam ? OldParam->

() :

;

(OldParamHasDfl && NewParamHasDfl) {

DiagDefaultParamID =

diag::err_param_default_argument_redefinition;

DiagDefaultParamID = diag::ext_param_default_argument_redefinition;

(

Older = PrevForDefaultArgs;

Older = Older->getPreviousDecl();

OldParam = Older->getParamDecl(p);

}

(OldParamHasDfl) {

}

(NewParamHasDfl) {

diag::err_param_default_argument_template_redecl)

diag::note_template_prev_declaration)

(

->getDescribedClassTemplate())

(isa<ClassTemplatePartialSpecializationDecl>(

))

diag::err_param_default_argument_member_template_redecl)

(isa<CXXConstructorDecl>(New) &&

(NewSM != OldSM) {

(NewParam->

(), diag::err_default_arg_makes_ctor_special)

(isa<CXXDeductionGuideDecl>(New) &&

(New->

(), diag::err_friend_decl_with_def_arg_redeclared);

? diag::warn_cxx23_placeholder_var_definition

: diag::ext_placeholder_var_definition);

assert(

.isDecompositionDeclarator());

(!

.mayHaveDecompositionDeclarator()) {

(!TemplateParamLists.empty()) {

(TemplateParamLists.front()->getTemplateLoc(),

diag::err_decomp_decl_template);

? diag::ext_decomp_decl

? diag::ext_decomp_decl_cond

: diag::warn_cxx14_compat_decomp_decl)

&DS =

.getDeclSpec();

(

SCS = DS.getStorageClassSpec()) {

CPlusPlus20SpecifierLocs.push_back(DS.getStorageClassSpecLoc());

BadSpecifierLocs.push_back(DS.getStorageClassSpecLoc());

(

TSCS = DS.getThreadStorageClassSpec()) {

CPlusPlus20SpecifierLocs.push_back(DS.getThreadStorageClassSpecLoc());

(DS.hasConstexprSpecifier()) {

BadSpecifiers.push_back(

BadSpecifierLocs.push_back(DS.getConstexprSpecLoc());

(DS.isInlineSpecified()) {

BadSpecifiers.push_back(

);

BadSpecifierLocs.push_back(DS.getInlineSpecLoc());

(!BadSpecifiers.empty()) {

&&Err =

(BadSpecifierLocs.front(), diag::err_decomp_decl_spec);

Err << (

)BadSpecifiers.size()

<< llvm::join(BadSpecifiers.begin(), BadSpecifiers.end(),

);

(

: BadSpecifierLocs)

}

(!CPlusPlus20Specifiers.empty()) {

&&Warn =

(CPlusPlus20SpecifierLocs.front(),

? diag::warn_cxx17_compat_decomp_decl_spec

: diag::ext_decomp_decl_spec);

Warn << (

)CPlusPlus20Specifiers.size()

<< llvm::join(CPlusPlus20Specifiers.begin(),

CPlusPlus20Specifiers.end(),

);

(

: CPlusPlus20SpecifierLocs)

(DS.getVolatileSpecLoc(),

diag::warn_deprecated_volatile_structured_binding);

.hasGroupingParens() ||

.getNumTypeObjects() > 1 ||

(

.getNumTypeObjects() == 1 &&

(

.hasGroupingParens() ||

(

.getNumTypeObjects() &&

? diag::err_decomp_decl_parens

: diag::err_decomp_decl_type)

(DS.isConstrainedAuto()) {

);

(

&B :

.getDecompositionDeclarator().bindings()) {

assert(VarName &&

);

RedeclarationKind::ForVisibleRedeclaration);

.getFoundDecl()->isTemplateParameter()) {

(B.EllipsisLoc.isValid()) {

(!cast<Decl>(DC)->isTemplated())

(B.EllipsisLoc, diag::err_pack_outside_template);

*ShadowedDecl =

.getCXXScopeSpec().isEmpty()

sameDC = (

.end() - 1)

*Old =

.getRepresentativeDecl();

(B.NameLoc, diag::err_redefinition) << B.Name;

(Old->getLocation(), diag::note_previous_definition);

}

(ShadowedDecl && !

.isRedeclaration()) {

RedeclarationKind::ForVisibleRedeclaration);

AddToScope =

;

(

().isInOpenMPDeclareTargetContext())

MemberCount) {

BindingWithPackItr =

[](

*

) ->

{ return D->isParameterPack(); });

HasPack = BindingWithPackItr !=

.end();

IsValid =

.size() == MemberCount;

IsValid = MemberCount >=

.size() - 1;

(IsValid && HasPack) {

PackSize = MemberCount -

.size() + 1;

DecompType, PackSize);

(

*&

: RP->getExprs()) {

NestedBD->setDecomposedDecl(DD);

S.

(DD->

(), diag::err_decomp_decl_wrong_number_bindings)

<< DecompType << (

)

.size() << MemberCount << MemberCount

<< (MemberCount <

.size());

*DD = cast<DecompositionDecl>(Src);

(

*B : DD->flat_bindings()) {

(

.isInvalid())

= GetInit(

,

.get(), I++);

(

.isInvalid())

B->setBinding(ElemType,

.get());

llvm::APSInt &NumElems,

S,

, Src, DecompType, NumElems, ElemType,

(

.isInvalid())

llvm::APSInt(CAT->

()),

S,

, Src, DecompType, llvm::APSInt::get(2),

return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);

llvm::raw_svector_ostream

(SS);

std::string(

.str());

DiagnoseMissing = [&] {

DiagnoseMissing();

DiagnoseMissing();

(

.isAmbiguous())

.suppressDiagnostics();

S.

(

, diag::err_std_type_trait_not_class_template) << Trait;

S.

(

->getLocation(), diag::note_declared_at);

, TraitTy, DiagID,

assert(RD &&

);

{

IsTupleLike { TupleLike, NotTupleLike,

}; }

llvm::APSInt &Size) {

IsTupleLike::NotTupleLike;

: R(R), Args(Args) {}

S.

(

, diag::err_decomp_decl_std_tuple_size_not_constant)

} Diagnoser(R, Args);

(

.isInvalid())

IsTupleLike::Error;

(

.isInvalid())

IsTupleLike::Error;

IsTupleLike::TupleLike;

S, R,

,

, Args,

diag::err_decomp_decl_std_tuple_element_not_specialized))

S.

(

, diag::err_decomp_decl_std_tuple_element_not_specialized)

InitializingBinding {

~InitializingBinding() {

llvm::APSInt &TupleSize) {

*DD = cast<DecompositionDecl>(Src);

UseMemberGet =

;

dyn_cast<FunctionTemplateDecl>(

->getUnderlyingDecl())) {

(TPL->

() != 0 &&

isa<NonTypeTemplateParmDecl>(TPL->

(0))) {

UseMemberGet =

;

(

*B : DD->flat_bindings()) {

InitializingBinding InitContext(S, B);

(

.isInvalid())

MemberGet, &Args,

);

(

.isInvalid())

*Arg =

.get();

(

.isInvalid())

B->getDeclName().getAsIdentifierInfo(), RefType,

RefVD->setImplicit();

RefVD->setInlineSpecified();

RefVD->getLexicalDeclContext()->addHiddenDecl(RefVD);

=

.Perform(S, Entity, Kind,

);

(

.isInvalid())

(

.isInvalid())

RefVD->setInit(

.get());

(

.isInvalid())

B->setBinding(

,

.get());

->getType()->getAsCXXRecordDecl()->hasDirectFields();

ClassWithFields = RD;

(

&

: Paths) {

BestPath->back().Base->getType())) {

S.

(

, diag::err_decomp_decl_multiple_bases_with_members)

<<

<< RD << BestPath->back().Base->getType()

<<

.back().Base->getType();

}

(

.Access < BestPath->

) {

BaseType = BestPath->back().Base->getType();

S.

(

, diag::err_decomp_decl_ambiguous_base)

*BestPath, diag::err_decomp_decl_inaccessible_base);

(ClassWithFields->

(BaseHasFields, Paths)) {

S.

(

, diag::err_decomp_decl_multiple_bases_with_members)

<< (ClassWithFields == RD) << RD << ClassWithFields

<< Paths.front().back().Base->getType();

diag::err_incomplete_type))

*DD = cast<DecompositionDecl>(Src);

NumFields = llvm::count_if(

RD->

(), [](

*FD) { return !FD->isUnnamedBitField(); });

FlatBindings = DD->flat_bindings();

assert(llvm::range_size(FlatBindings) == NumFields);

FlatBindingsItr = FlatBindings.begin();

(

*FD : RD->

()) {

S.

(Src->

(), diag::err_decomp_decl_anon_union_member)

assert(FlatBindingsItr != FlatBindings.end());

(

.isInvalid())

(

.isInvalid())

(

.isInvalid())

(FD->isMutable())

(

*B : DD->

()) {

(B->getType().isNull())

llvm::APSInt TupleSize(32);

IsTupleLike::Error:

IsTupleLike::TupleLike:

IsTupleLike::NotTupleLike:

<< DD << !RD << DecompType;

);

NewType =

->getPointeeType();

(FTD->isMemberSpecialization())

(Param->

(), diag::err_param_default_argument_missing_name)

(Param->

(), diag::err_param_default_argument_missing);

<

... Ts>

std::forward<Ts>(DiagArgs)...);

llvm_unreachable(

);

);

(!Check(B.getBaseTypeLoc(), B.getType(),

))

(!Check(FD->getLocation(), FD->getType(), FD))

);

ArgIndex = 0;

e = FT->param_type_end();

i != e; ++i, ++ArgIndex) {

assert(PD &&

);

diag::err_constexpr_non_literal_param, ArgIndex + 1,

);

diag::err_constexpr_non_literal_return,

: llvm_unreachable(

);

<< isa<CXXConstructorDecl>(NewFD)

(

&I : RD->

())

(I.getBeginLoc(), diag::note_constexpr_virtual_base_here)

<< I.getSourceRange();

(!isa<CXXConstructorDecl>(NewFD)) {

*Method = dyn_cast<CXXMethodDecl>(NewFD);

(Method->

(), diag::warn_cxx17_compat_constexpr_virtual);

(WrittenVirtual != Method)

diag::note_overridden_virtual_function);

(

*Dtor = dyn_cast<CXXDestructorDecl>(NewFD)) {

!Dtor->getParent()->defaultedDestructorIsConstexpr()) {

);

(

*DclIt : DS->

()) {

(DclIt->getKind()) {

Decl::StaticAssert:

Decl::UsingShadow:

Decl::UsingDirective:

Decl::UnresolvedUsingTypename:

Decl::UnresolvedUsingValue:

Decl::UsingEnum:

Decl::TypeAlias: {

*TN = cast<TypedefNameDecl>(DclIt);

(TN->getUnderlyingType()->isVariablyModifiedType()) {

TL = TN->getTypeSourceInfo()->getTypeLoc();

<< isa<CXXConstructorDecl>(Dcl);

Decl::CXXRecord:

(cast<TagDecl>(DclIt)->isThisDeclarationADefinition()) {

? diag::warn_cxx11_compat_constexpr_type_definition

: diag::ext_constexpr_type_definition)

<< isa<CXXConstructorDecl>(Dcl);

Decl::EnumConstant:

Decl::IndirectField:

Decl::Decomposition: {

*VD = cast<VarDecl>(DclIt);

(VD->isThisDeclarationADefinition()) {

(VD->isStaticLocal()) {

? diag::warn_cxx20_compat_constexpr_var

: diag::ext_constexpr_static_var)

<< isa<CXXConstructorDecl>(Dcl)

diag::warn_cxx20_compat_constexpr_var,

isa<CXXConstructorDecl>(Dcl),

, Kind, VD->getLocation(), VD->getType(),

diag::err_constexpr_local_var_non_literal_type,

isa<CXXConstructorDecl>(Dcl))) {

(!VD->getType()->isDependentType() &&

!VD->hasInit() && !VD->isCXXForRangeDecl()) {

? diag::warn_cxx17_compat_constexpr_local_var_no_init

: diag::ext_constexpr_local_var_no_init)

<< isa<CXXConstructorDecl>(Dcl);

? diag::warn_cxx11_compat_constexpr_local_var

: diag::ext_constexpr_local_var)

<< isa<CXXConstructorDecl>(Dcl);

Decl::NamespaceAlias:

Decl::Function:

<< isa<CXXConstructorDecl>(Dcl) << Dcl->

();

llvm::SmallSet<Decl*, 16> &Inits,

(Field->isInvalidDecl())

(Field->isUnnamedBitField())

(Field->isAnonymousStructOrUnion() &&

(Field->getType()->isUnionType()

? !Field->getType()->getAsCXXRecordDecl()->hasVariantMembers()

: Field->getType()->getAsCXXRecordDecl()->isEmpty()))

(!Inits.count(Field)) {

? diag::warn_cxx17_compat_constexpr_ctor_missing_init

: diag::ext_constexpr_ctor_missing_init);

diag::note_constexpr_ctor_missing_init);

}

(Field->isAnonymousStructOrUnion()) {

(

*I : RD->

())

(!RD->

() || Inits.count(I))

(S->getStmtClass()) {

Stmt::NullStmtClass:

Stmt::DeclStmtClass:

Stmt::ReturnStmtClass:

(isa<CXXConstructorDecl>(Dcl)) {

Cxx1yLoc = S->getBeginLoc();

ReturnStmts.push_back(S->getBeginLoc());

Stmt::AttributedStmtClass:

, Dcl, cast<AttributedStmt>(S)->getSubStmt(), ReturnStmts,

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind);

Stmt::CompoundStmtClass: {

Cxx1yLoc = S->getBeginLoc();

(

*BodyIt : CompStmt->

()) {

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Stmt::IfStmtClass: {

Cxx1yLoc = S->getBeginLoc();

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

(

->getElse() &&

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Stmt::WhileStmtClass:

Stmt::DoStmtClass:

Stmt::ForStmtClass:

Stmt::CXXForRangeStmtClass:

Stmt::ContinueStmtClass:

Cxx1yLoc = S->getBeginLoc();

(

*SubStmt : S->children()) {

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Stmt::SwitchStmtClass:

Stmt::CaseStmtClass:

Stmt::DefaultStmtClass:

Stmt::BreakStmtClass:

Cxx1yLoc = S->getBeginLoc();

(

*SubStmt : S->children()) {

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Stmt::LabelStmtClass:

Stmt::GotoStmtClass:

Cxx2bLoc = S->getBeginLoc();

(

*SubStmt : S->children()) {

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Stmt::GCCAsmStmtClass:

Stmt::MSAsmStmtClass:

Stmt::CXXTryStmtClass:

Cxx2aLoc = S->getBeginLoc();

(

*SubStmt : S->children()) {

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Stmt::CXXCatchStmtClass:

, Dcl, cast<CXXCatchStmt>(S)->getHandlerBlock(), ReturnStmts,

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

Cxx1yLoc = S->getBeginLoc();

.

(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)

<< isa<CXXConstructorDecl>(Dcl) << Dcl->

();

(isa<CXXTryStmt>(Body)) {

? diag::ext_constexpr_function_try_block_cxx20

: diag::warn_cxx17_compat_constexpr_function_try_block)

<< isa<CXXConstructorDecl>(Dcl);

Cxx1yLoc, Cxx2aLoc, Cxx2bLoc, Kind))

}

(Cxx2bLoc.

()) {

? diag::warn_cxx20_compat_constexpr_body_invalid_stmt

: diag::ext_constexpr_body_invalid_stmt_cxx23)

<< isa<CXXConstructorDecl>(Dcl);

}

(Cxx2aLoc.

()) {

? diag::warn_cxx17_compat_constexpr_body_invalid_stmt

: diag::ext_constexpr_body_invalid_stmt_cxx20)

<< isa<CXXConstructorDecl>(Dcl);

}

(Cxx1yLoc.

()) {

? diag::warn_cxx11_compat_constexpr_body_invalid_stmt

: diag::ext_constexpr_body_invalid_stmt)

<< isa<CXXConstructorDecl>(Dcl);

= dyn_cast<CXXConstructorDecl>(Dcl)) {

(Constructor->getNumCtorInitializers() == 0 &&

? diag::warn_cxx17_compat_constexpr_union_ctor_no_init

: diag::ext_constexpr_union_ctor_no_init);

}

(!Constructor->isDependentContext() &&

!Constructor->isDelegatingConstructor()) {

assert(RD->

() == 0 &&

);

AnyAnonStructUnionMembers =

;

Fields = 0;

(I->isAnonymousStructOrUnion()) {

AnyAnonStructUnionMembers =

;

(AnyAnonStructUnionMembers ||

Constructor->getNumCtorInitializers() != RD->

() + Fields) {

llvm::SmallSet<Decl*, 16> Inits;

(

*I: Constructor->inits()) {

Inits.insert(ID->chain_begin(), ID->chain_end());

Diagnosed =

;

(

*I : RD->

())

(ReturnStmts.empty()) {

}

(ReturnStmts.size() > 1) {

? diag::warn_cxx11_compat_constexpr_body_multiple_return

: diag::ext_constexpr_body_multiple_return);

(

I = 0; I < ReturnStmts.size() - 1; ++I)

diag::note_constexpr_body_previous_return);

diag::ext_constexpr_function_never_constant_expr, Dcl->

());

diag::ext_constexpr_function_never_constant_expr)

<< isa<CXXConstructorDecl>(Dcl) << Dcl->

()

(

I = 0, N =

.size(); I != N; ++I)

OK ? diag::warn_cxx11_compat_constexpr_body_no_return

: diag::err_constexpr_body_no_return)

(it->second, diag::err_immediate_function_used_before_definition)

);

assert(FD->

() &&

);

ImmediateFnIsConstructor;

: SemaRef(SemaRef), ImmediateFn(FD),

ImmediateFnIsConstructor(isa<CXXConstructorDecl>(FD)) {

ShouldVisitImplicitCode =

;

ShouldVisitLambdaBody =

;

(CurrentConstructor && CurrentInit) {

SemaRef.

(

, diag::note_immediate_function_reason)

<< ImmediateFn << Fn << Fn->isConsteval() << IsCall

<< isa<CXXConstructorDecl>(Fn) << ImmediateFnIsConstructor

<< (InitializedField !=

)

<< (CurrentInit && !CurrentInit->

())

<< InitializedField <<

;

TraverseCallExpr(

*

)

{

(

*DR =

DR && DR->isImmediateEscalating()) {

(

,

->getDirectCallee(),

);

(

*A :

->arguments())

(!TraverseStmt(A))

(

*ReferencedFn = dyn_cast<FunctionDecl>(

->getDecl());

ReferencedFn &&

->isImmediateEscalating()) {

(

, ReferencedFn,

);

(

->isImmediateEscalating()) {

DynamicRecursiveASTVisitor::TraverseCXXConstructorDecl(Ctr);

TraverseType(

)

{

; }

VisitBlockExpr(

*

)

{

; }

} Visitor(*

, FD);

Visitor.TraverseDecl(FD);

dyn_cast_or_null<CXXRecordDecl>(DC);

dyn_cast_or_null<CXXRecordDecl>(

);

CurDecl = dyn_cast_or_null<CXXRecordDecl>(DC);

CurDecl = dyn_cast_or_null<CXXRecordDecl>(

);

(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)

(BaseDecl->isUnion()) {

(BaseLoc, diag::err_union_as_base_class) << SpecifierRange;

(BaseLoc, diag::warn_qual_base_type)

<< Quals << std::count(Quals.begin(), Quals.end(),

) + 1

(BaseLoc, diag::note_base_class_specified_here) << BaseType;

(

*BaseSpec =

dyn_cast<ClassTemplateSpecializationDecl>(BaseDecl)) {

->setInvalidDecl();

BaseDecl = BaseDecl->getDefinition();

assert(BaseDecl &&

);

*BaseCSA = BaseDecl->getAttr<CodeSegAttr>();

*DerivedCSA =

->getAttr<CodeSegAttr>();

((DerivedCSA || BaseCSA) &&

(!BaseCSA || !DerivedCSA ||

BaseCSA->getName() != DerivedCSA->getName())) {

(

->getLocation(), diag::err_mismatched_code_seg_base);

(BaseDecl->getLocation(), diag::note_base_class_specified_here)

(BaseDecl->hasFlexibleArrayMember()) {

(BaseLoc, diag::err_base_class_has_flexible_array_member)

<< BaseDecl->getDeclName();

(FinalAttr *FA = BaseDecl->getAttr<FinalAttr>()) {

(BaseLoc, diag::err_class_marked_final_used_as_base)

<< BaseDecl->getDeclName() << FA->isSpelledAsSealed();

(BaseDecl->getLocation(), diag::note_entity_declared_at)

<< BaseDecl->getDeclName() << FA->getRange();

(BaseDecl->isInvalidDecl())

->setInvalidDecl();

(!

->isDependentContext())

->setInvalidDecl();

(BaseLoc, diag::err_base_must_be_class) << SpecifierRange;

Access, TInfo, EllipsisLoc);

->setIsParsingBaseSpecifiers();

(AL.getLoc(), diag::warn_unknown_attribute_ignored)

<< AL << AL.getRange();

(AL.getLoc(), diag::err_base_specifier_attribute)

<< AL << AL.isRegularKeywordAttribute() << AL.getRange();

(

->isUnion()) {

(

->getLocation(), diag::err_base_clause_on_union)

->setInvalidDecl();

= Rec->getAsCXXRecordDecl();

(

&BaseSpec :

->bases()) {

(

.insert(

).second)

std::map<QualType, CXXBaseSpecifier*, QualTypeOrdering> KnownBaseTypes;

NumGoodBases = 0;

(

idx = 0; idx < Bases.size(); ++idx) {

(Bases[idx]->getBeginLoc(), diag::err_duplicate_base_class)

<< KnownBase->

() << Bases[idx]->getSourceRange();

KnownBase = Bases[idx];

Bases[NumGoodBases++] = Bases[idx];

(Bases.size() > 1)

(

->isInterface() &&

(KnownBase->

(), diag::err_invalid_base_in_interface)

(RD->

<WeakAttr>())

->setBases(Bases.data(), NumGoodBases);

(

idx = 0; idx < NumGoodBases; ++idx) {

BaseType = Bases[idx]->getType();

(IndirectBaseTypes.count(CanonicalBase)) {

=

->isDerivedFrom(CanonicalBase->getAsCXXRecordDecl(), Paths);

(Paths.isAmbiguous(CanonicalBase))

(Bases[idx]->getBeginLoc(), diag::warn_inaccessible_base_class)

<< Bases[idx]->getSourceRange();

assert(Bases[idx]->isVirtual());

(!ClassDecl || Bases.empty())

(

I =

.size(); I != 0; --I) {

(

[I - 1].

->isVirtual()) {

(

I = Start,

=

.size(); I !=

; ++I)

assert(BasePathArray.empty() &&

);

assert(Paths.isRecordingPaths() &&

);

return ::BuildBasePathArray(Paths.front(), BasePathArray);

InaccessibleBaseID,

AmbiguousBaseConvID,

IgnoreAccess) {

(!DerivationOkay)

= &Paths.front();

(PossiblePath.size() == 1) {

= &PossiblePath;

(AmbiguousBaseConvID)

(

, diag::ext_ms_ambiguous_direct_base)

(!IgnoreAccess) {

(AmbiguousBaseConvID) {

Paths.setRecordingPaths(

);

assert(StillOkay &&

);

(

, AmbiguousBaseConvID)

<< Derived <<

<< PathDisplayStr <<

<< Name;

IgnoreAccess) {

Derived,

, diag::err_upcast_to_inaccessible_base,

BasePath, IgnoreAccess);

std::string PathDisplayStr;

std::set<unsigned> DisplayedPaths;

(DisplayedPaths.insert(

->back().SubobjectNumber).second) {

PathDisplayStr +=

;

(CXXBasePath::const_iterator Element =

->begin();

Element !=

->end(); ++Element)

PathDisplayStr +=

+ Element->Base->getType().getAsString();

PathDisplayStr;

assert(Access !=

&&

);

(!OverloadedMethods.empty()) {

(OverrideAttr *OA =

->

<OverrideAttr>()) {

(OA->getLocation(),

diag::override_keyword_hides_virtual_member_function)

<<

<< (OverloadedMethods.size() > 1);

}

(FinalAttr *FA =

->

<FinalAttr>()) {

(FA->getLocation(),

diag::override_keyword_hides_virtual_member_function)

<< (FA->isSpelledAsSealed() ?

:

)

<< (OverloadedMethods.size() > 1);

(OverrideAttr *OA =

->

<OverrideAttr>()) {

(OA->getLocation(),

diag::override_keyword_only_allowed_on_virtual_member_functions)

(FinalAttr *FA =

->

<FinalAttr>()) {

(FA->getLocation(),

diag::override_keyword_only_allowed_on_virtual_member_functions)

<< (FA->isSpelledAsSealed() ?

:

)

(MD->

<OverrideAttr>() && !HasOverriddenMethods)

(MD->

(), diag::err_function_marked_override_not_overriding)

EmitDiag = [&](

DiagInconsistent,

DiagSuggest) {

(isa<CXXDestructorDecl>(MD))

diag::warn_inconsistent_destructor_marked_not_override_overriding,

diag::warn_suggest_destructor_marked_not_override_overriding);

EmitDiag(diag::warn_inconsistent_function_marked_not_override_overriding,

diag::warn_suggest_function_marked_not_override_overriding);

FinalAttr *FA = Old->

<FinalAttr>();

<< FA->isSpelledAsSealed();

!RD->isCompleteDefinition() ||

!RD->hasTrivialDefaultConstructor() ||

!RD->hasTrivialDestructor();

std::map<CXXRecordDecl*, NamedDecl*> Bases;

=

->getType()->getAsCXXRecordDecl();

(Bases.find(

) != Bases.end())

(

Field :

->lookup(FieldName)) {

((isa<FieldDecl>(Field) || isa<IndirectFieldDecl>(Field)) &&

assert(Bases.find(

) == Bases.end());

(

&

: Paths) {

=

.back().Base->getType()->getAsCXXRecordDecl();

It = Bases.find(

);

(It == Bases.end())

BaseField = It->second;

assert(BaseField->getAccess() !=

);

(

, diag::warn_shadow_field)

<< FieldName << RD <<

<< DeclIsField;

(BaseField->getLocation(), diag::note_shadow_field);

<

AttrType>

TD->hasAttr<AttrType>();

TDT->getDecl()->hasAttr<AttrType>();

(HasAttribute<WarnUnusedAttr>(FieldType))

!HasAttribute<UnusedAttr>(FieldType) &&

*BitWidth =

*

(BW);

isFunc =

.isDeclarationOfFunction();

.getDeclSpec().getAttributes().getMSPropertyAttr();

(cast<CXXRecordDecl>(

)->isInterface()) {

InvalidDecl;

ShowDeclName =

;

(Name.getNameKind()) {

ShowDeclName =

;

ShowDeclName =

;

(

, diag::err_invalid_member_in_interface)

<< (InvalidDecl-1) << Name;

(

, diag::err_invalid_member_in_interface)

<< (InvalidDecl-1) <<

;

.getMutableDeclSpec().ClearStorageClassSpecs();

diag::err_storageclass_invalid_for_member);

.getMutableDeclSpec().ClearStorageClassSpecs();

!isFunc && TemplateParameterLists.empty();

.getMutableDeclSpec().ClearConstexprSpec();

*PrevSpec;

Failed =

.getMutableDeclSpec().SetTypeQual(

assert(!Failed &&

);

*PrevSpec;

(

.getMutableDeclSpec().SetStorageClassSpec(

);

isInstField =

;

(!Name.isIdentifier()) {

(

, diag::err_bad_variable_name)

(

.getIdentifierLoc(), diag::err_member_with_template_arguments)

.getName().TemplateId->RAngleLoc)

<<

.getName().TemplateId->LAngleLoc;

.SetIdentifier(II,

);

?

.getName().TemplateId

(

.getIdentifierLoc(), diag::err_member_qualification)

(MSPropertyAttr) {

BitWidth, InitStyle, AS, *MSPropertyAttr);

isInstField =

;

BitWidth, InitStyle, AS);

CheckShadowInheritedFields(

, Name, cast<CXXRecordDecl>(

));

(

->isInvalidDecl()) {

}

(isa<VarDecl>(

) || isa<VarTemplateDecl>(

)) {

(

, diag::err_static_not_bitfield)

}

(isa<TypedefDecl>(

)) {

(

, diag::err_typedef_not_bitfield)

(

, diag::err_not_integral_type_bitfield)

<< Name << cast<ValueDecl>(

)->getType()

BitWidth =

;

->setInvalidDecl();

NonTemplateMember = FunTmpl->getTemplatedDecl();

NonTemplateMember = VarTmpl->getTemplatedDecl();

(NonTemplateMember !=

)

(

*DG = dyn_cast<CXXDeductionGuideDecl>(NonTemplateMember)) {

*TD = DG->getDeducedTemplate();

(AS != TD->getAccess() &&

TD->getDeclContext()->getRedeclContext()->Equals(

DG->getDeclContext()->getRedeclContext())) {

(DG->getBeginLoc(), diag::err_deduction_guide_wrong_access);

(TD->getBeginLoc(), diag::note_deduction_guide_template_access)

(

*

: cast<CXXRecordDecl>(

)->decls()) {

(

*AccessSpec = dyn_cast<AccessSpecDecl>(

))

LastAccessSpec = AccessSpec;

assert(LastAccessSpec &&

);

(LastAccessSpec->

(), diag::note_deduction_guide_access)

? FinalAttr::Keyword_sealed

: FinalAttr::Keyword_final));

assert((Name || isInstField) &&

);

UninitializedFieldVisitor

llvm::SmallPtrSetImpl<ValueDecl*> &Decls;

llvm::SmallPtrSetImpl<QualType> &BaseClasses;

UninitializedFieldVisitor(

&S,

llvm::SmallPtrSetImpl<ValueDecl*> &Decls,

llvm::SmallPtrSetImpl<QualType> &BaseClasses)

: Inherited(S.Context), S(S), Decls(Decls), BaseClasses(BaseClasses),

Constructor(nullptr), InitList(

), InitListFieldDecl(nullptr) {}

IsInitListMemberExprInitialized(

*ME,

CheckReferenceOnly) {

ReferenceField =

;

Fields.push_back(FD);

ReferenceField =

;

(CheckReferenceOnly && !ReferenceField)

(

*FD : llvm::drop_begin(llvm::reverse(Fields)))

(

UsedIter = UsedFieldIndex.begin(),

UsedEnd = UsedFieldIndex.end(),

OrigIter = InitFieldIndex.begin(),

OrigEnd = InitFieldIndex.end();

UsedIter != UsedEnd && OrigIter != OrigEnd; ++UsedIter, ++OrigIter) {

(*UsedIter < *OrigIter)

(*UsedIter > *OrigIter)

HandleMemberExpr(

*ME,

CheckReferenceOnly,

dyn_cast<MemberExpr>(

->IgnoreParenImpCasts())) {

(isa<VarDecl>(SubME->getMemberDecl()))

(

*FD = dyn_cast<FieldDecl>(SubME->getMemberDecl()))

AllPODFields =

;

= SubME->getBase();

(!isa<CXXThisExpr>(

->IgnoreParenImpCasts())) {

(AddressOf && AllPODFields)

(isa<ImplicitCastExpr>(BaseCast->getSubExpr())) {

BaseCast = cast<ImplicitCastExpr>(BaseCast->getSubExpr());

(BaseCast->getCastKind() == CK_UncheckedDerivedToBase) {

S.

(FieldME->

(), diag::warn_base_class_is_uninit)

(!Decls.count(FoundVD))

(InitList && !AddressOf && FoundVD == InitListFieldDecl) {

(IsInitListMemberExprInitialized(ME, CheckReferenceOnly)) {

(CheckReferenceOnly && !IsReference)

diag = IsReference

? diag::warn_reference_field_is_uninit

: diag::warn_field_is_uninit;

diag::note_uninit_in_this_constructor)

HandleValue(

*

,

AddressOf) {

(

*ME = dyn_cast<MemberExpr>(

)) {

HandleMemberExpr(ME,

,

Visit(CO->getCond());

HandleValue(CO->getTrueExpr(), AddressOf);

HandleValue(CO->getFalseExpr(), AddressOf);

dyn_cast<BinaryConditionalOperator>(

)) {

Visit(BCO->getCond());

HandleValue(BCO->getFalseExpr(), AddressOf);

HandleValue(OVE->getSourceExpr(), AddressOf);

(BO->getOpcode()) {

HandleValue(BO->getLHS(), AddressOf);

Visit(BO->getRHS());

Visit(BO->getLHS());

HandleValue(BO->getRHS(), AddressOf);

InitFieldIndex.push_back(0);

(

*Child : ILE->

()) {

(

*SubList = dyn_cast<InitListExpr>(Child)) {

CheckInitListExpr(SubList);

++InitFieldIndex.back();

InitFieldIndex.pop_back();

DeclsToRemove.clear();

InitListFieldDecl =

;

InitFieldIndex.clear();

CheckInitListExpr(ILE);

HandleMemberExpr(ME,

,

);

(

->getCastKind() == CK_LValueToRValue) {

HandleValue(

->getSubExpr(),

);

Inherited::VisitImplicitCastExpr(

);

(

->getConstructor()->isCopyConstructor()) {

*ArgExpr =

->getArg(0);

(

*ILE = dyn_cast<InitListExpr>(ArgExpr))

(ICE->getCastKind() == CK_NoOp)

ArgExpr = ICE->getSubExpr();

HandleValue(ArgExpr,

);

Inherited::VisitCXXConstructExpr(

);

(isa<MemberExpr>(Callee)) {

HandleValue(Callee,

);

(

*Arg :

->arguments())

Inherited::VisitCXXMemberCallExpr(

);

(

->isCallToStdMove()) {

HandleValue(

->getArg(0),

);

Inherited::VisitCallExpr(

);

(isa<UnresolvedLookupExpr>(Callee))

Inherited::VisitCXXOperatorCallExpr(

);

(

*Arg :

->arguments())

HandleValue(Arg->IgnoreParenImpCasts(),

);

(

->getOpcode() == BO_Assign)

(

*ME = dyn_cast<MemberExpr>(

->getLHS()))

DeclsToRemove.push_back(FD);

(

->isCompoundAssignmentOp()) {

HandleValue(

->getLHS(),

);

Visit(

->getRHS());

Inherited::VisitBinaryOperator(

);

(

->isIncrementDecrementOp()) {

HandleValue(

->getSubExpr(),

);

(

->getOpcode() == UO_AddrOf) {

(

*ME = dyn_cast<MemberExpr>(

->getSubExpr())) {

HandleValue(ME->

(),

);

Inherited::VisitUnaryOperator(

);

DiagnoseUninitializedFields(

(

*I : RD->

()) {

(

*FD = dyn_cast<FieldDecl>(I)) {

UninitializedFields.insert(FD);

}

(

*IFD = dyn_cast<IndirectFieldDecl>(I)) {

UninitializedFields.insert(IFD->getAnonField());

(

&I : RD->

())

UninitializedBaseClasses.insert(I.getType().getCanonicalType());

(UninitializedFields.empty() && UninitializedBaseClasses.empty())

UninitializedFieldVisitor UninitializedChecker(

,

UninitializedFields,

UninitializedBaseClasses);

(

*FieldInit :

->inits()) {

(UninitializedFields.empty() && UninitializedBaseClasses.empty())

*InitExpr = FieldInit->getInit();

dyn_cast<CXXDefaultInitExpr>(InitExpr)) {

InitExpr =

->getExpr();

UninitializedChecker.CheckInitializer(InitExpr, Constructor,

FieldInit->getAnyMember(),

FieldInit->getBaseClass());

UninitializedChecker.CheckInitializer(InitExpr,

,

FieldInit->getAnyMember(),

FieldInit->getBaseClass());

(!

.isFunctionDeclarator())

&FTI =

.getFunctionTypeInfo();

*ParamDecl = cast<NamedDecl>(Param.Param);

(ParamDecl->getDeclName())

ConstraintExpr;

.Perform(*

, Entity, Kind, InitExpr);

(isa<MSPropertyDecl>(

)) {

);

assert(

.isUsable() &&

);

(!

.isInvalid())

(

.isInvalid()) {

DirectBaseSpec =

;

(

&

: ClassDecl->

()) {

DirectBaseSpec = &

;

VirtualBaseSpec =

;

(!DirectBaseSpec || !DirectBaseSpec->

()) {

(

->back().Base->isVirtual()) {

VirtualBaseSpec =

->back().Base;

DirectBaseSpec || VirtualBaseSpec;

DS, IdLoc, InitList,

DS, IdLoc, List, EllipsisLoc);

MemInitializerValidatorCCC(

*ClassDecl)

: ClassDecl(ClassDecl) {}

ValidateCandidate(

&candidate)

{

->getDeclContext()->getRedeclContext()->Equals(ClassDecl);

isa<TypeDecl>(ND);

std::unique_ptr<CorrectionCandidateCallback> clone()

{

std::make_unique<MemInitializerValidatorCCC>(*

);

isa<FieldDecl, IndirectFieldDecl>(Elem) &&

(

, diag::err_using_placeholder_variable) << Name;

(isa<FieldDecl, IndirectFieldDecl>(ND) &&

(

*

: ClassDecl->

(MemberOrBase)) {

(isa<FieldDecl, IndirectFieldDecl>(

)) {

IsPlaceholder =

->isPlaceholderVar(

());

cast<ValueDecl>(

);

ND = cast<ValueDecl>(

);

= dyn_cast<CXXConstructorDecl>(ConstructorD);

ClassDecl, SS, TemplateTypeTy, MemberOrBase)) {

(EllipsisLoc, diag::err_pack_expansion_member_init)

(TemplateTypeTy) {

NotUnknownSpecialization =

;

NotUnknownSpecialization = !

->hasAnyDependentBases();

(!NotUnknownSpecialization) {

*TempSpec = cast<TemplateSpecializationType>(

UnqualifiedBase->getInjectedClassNameSpecialization());

(

&

: ClassDecl->

()) {

(IdLoc, diag::ext_unqualified_base_class)

BaseType =

.getType();

MemInitializerValidatorCCC CCC(ClassDecl);

(diag::err_mem_init_not_member_or_class_suggest)

<< MemberOrBase <<

);

DirectBaseSpec, VirtualBaseSpec)) {

(diag::err_mem_init_not_member_or_class_suggest)

<< MemberOrBase <<

,

(BaseSpec->

(), diag::note_base_class_specified_here)

(!TyD && BaseType.

()) {

(IdLoc, diag::err_mem_init_not_member_or_class)

<< MemberOrBase <<

(IdLoc,

->getSourceRange().getEnd());

(BaseType.

()) {

assert((DirectMember || IndirectMember) &&

);

(

->isInvalidDecl())

Args =

(ParenList->getExprs(), ParenList->getNumExprs());

Args =

(InitList->getInits(), InitList->getNumInits());

(

->getType()->isDependentType() ||

->isTypeDependent()) {

InitList =

;

(isa<InitListExpr>(

)) {

IdLoc,

->getBeginLoc(),

->getEndLoc())

(NameLoc, diag::err_delegating_ctor)

(NameLoc, diag::warn_cxx98_compat_delegating_ctor);

InitList =

;

Args =

(ParenList->getExprs(), ParenList->getNumExprs());

NameLoc,

->getBeginLoc(),

->getEndLoc())

cast<CXXConstructExpr>(DelegationInit.

())->getConstructor()) &&

);

DelegationInit.

(), InitRange.

(),

);

DelegationInit =

;

(BaseLoc, diag::err_base_init_does_not_name_class)

(EllipsisLoc.

()) {

(EllipsisLoc, diag::err_pack_expansion_without_parameter_packs)

(!DirectBaseSpec && !VirtualBaseSpec) {

(BaseLoc, diag::err_not_direct_base_or_virtual)

InitRange.

(), EllipsisLoc);

(DirectBaseSpec && VirtualBaseSpec)

(BaseLoc, diag::err_base_init_direct_and_virtual)

BaseSpec = VirtualBaseSpec;

InitList =

;

Args =

(ParenList->getExprs(), ParenList->getNumExprs());

BaseInit = InitSeq.

(*

, BaseEntity, Kind, Args,

);

InitRange.

(), EllipsisLoc);

TargetType, ExprLoc);

IsInheritedVirtualBase,

IsInheritedVirtualBase);

(ImplicitInitKind) {

BaseInit = InitSeq.Perform(

, InitEntity, InitKind, {});

Moving = ImplicitInitKind ==

;

*Param = Constructor->getParamDecl(0);

Constructor->getLocation(), ParamType,

BasePath.push_back(BaseSpec);

CK_UncheckedDerivedToBase,

BaseInit = InitSeq.

(

, InitEntity, InitKind, CopyCtorArg);

*Referenced = cast<MemberExpr>(MemRef)->getMemberDecl();

(Field->isInvalidDecl())

Moving = ImplicitInitKind ==

;

*Param = Constructor->getParamDecl(0);

(Field->isZeroLengthBitField())

*MemberExprBase =

);

(MemberInit.isInvalid())

(!Field->getParent()->isUnion()) {

diag::err_uninitialized_member_in_ctor)

<< (

)Constructor->isImplicit()

<< 0 << Field->getDeclName();

.

(Field->getLocation(), diag::note_declared_at);

diag::err_uninitialized_member_in_ctor)

<< (

)Constructor->isImplicit()

<< 1 << Field->getDeclName();

.

(Field->getLocation(), diag::note_declared_at);

CXXMemberInit =

;

BaseAndFieldInfo {

AnyErrorsInInits;

llvm::DenseMap<const void *, CXXCtorInitializer*> AllBaseFields;

llvm::DenseMap<TagDecl*, FieldDecl*> ActiveUnionMember;

: S(S), Ctor(Ctor), AnyErrorsInInits(ErrorsInInits) {

isImplicitCopyOrMove()

{

llvm_unreachable(

);

AllToInit.push_back(

);

(

->getInit()->HasSideEffects(S.

))

isInactiveUnionMember(

*Field) {

(!

->isUnion())

ActiveUnionMember.lookup(

->getCanonicalDecl()))

Active !=

->getCanonicalDecl();

(isImplicitCopyOrMove())

(

->hasInClassInitializer())

(!

->isAnonymousStructOrUnion())

isWithinInactiveUnionMember(

*Field,

isInactiveUnionMember(Field);

(Field && isInactiveUnionMember(Field))

(ArrayT->isZeroSize())

= ArrayT->getElementType();

(Field->isInvalidDecl())

Info.AllBaseFields.lookup(Field->getCanonicalDecl()))

Info.addFieldInitializer(

);

(Info.isWithinInactiveUnionMember(Field,

))

(Field->hasInClassInitializer() && !Info.isImplicitCopyOrMove()) {

Info.addFieldInitializer(

);

(Info.AnyErrorsInInits)

Info.addFieldInitializer(

);

Constructor->setNumCtorInitializers(1);

Constructor->setCtorInitializers(initializer);

DiagnoseUninitializedFields(*

, Constructor);

(Constructor->isDependentContext()) {

(!Initializers.empty()) {

Constructor->setNumCtorInitializers(Initializers.size());

(baseOrMemberInitializers, Initializers.data(),

Constructor->setCtorInitializers(baseOrMemberInitializers);

Constructor->setInvalidDecl();

BaseAndFieldInfo Info(*

, Constructor, AnyErrors);

*ClassDecl = Constructor->getParent()->getDefinition();

HadError =

;

(

i = 0; i < Initializers.size(); i++) {

(

->isBaseInitializer())

Info.AllBaseFields[

->getAnyMember()->getCanonicalDecl()] =

;

(

*

: F->chain()) {

Info.ActiveUnionMember.insert(std::make_pair(

Info.ActiveUnionMember.insert(std::make_pair(

(

&I : ClassDecl->

()) {

DirectVBases.insert(&I);

(

&VBase : ClassDecl->

()) {

= Info.AllBaseFields.lookup(VBase.getType()->getAs<

>())) {

(

->getSourceLocation(), diag::warn_abstract_vbase_init_ignored)

<< VBase.getType() << ClassDecl;

Info.AllToInit.push_back(

);

}

(!AnyErrors && !ClassDecl->

()) {

IsInheritedVirtualBase = !DirectVBases.count(&VBase);

&VBase, IsInheritedVirtualBase,

Info.AllToInit.push_back(CXXBaseInit);

(

&

: ClassDecl->

()) {

(

.isVirtual())

= Info.AllBaseFields.lookup(

.getType()->getAs<

>())) {

Info.AllToInit.push_back(

);

}

(!AnyErrors) {

Info.AllToInit.push_back(CXXBaseInit);

(

*Mem : ClassDecl->

()) {

(

*F = dyn_cast<FieldDecl>(Mem)) {

(F->isUnnamedBitField())

(F->isAnonymousStructOrUnion() && !Info.isImplicitCopyOrMove())

(Info.isImplicitCopyOrMove())

(

*F = dyn_cast<IndirectFieldDecl>(Mem)) {

(F->getType()->isIncompleteArrayType()) {

);

NumInitializers = Info.AllToInit.size();

(NumInitializers > 0) {

Constructor->setNumCtorInitializers(NumInitializers);

(baseOrMemberInitializers, Info.AllToInit.data(),

Constructor->setCtorInitializers(baseOrMemberInitializers);

Constructor->getParent());

(

*Field : RD->

())

IdealInits.push_back(Field->getCanonicalDecl());

(!

->isAnyMemberInitializer())

->getAnyMember()->getCanonicalDecl();

(

->isAnyMemberInitializer())

<< 1 <<

->getTypeSourceInfo()->getType();

(Current->isAnyMemberInitializer())

<< 0 << Current->getAnyMember();

<< 1 << Current->getTypeSourceInfo()->getType();

(Constructor->getDeclContext()->isDependentContext())

ShouldCheckOrder =

;

(

InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {

->getSourceLocation())) {

ShouldCheckOrder =

;

(!ShouldCheckOrder)

(

&VBase : ClassDecl->

())

(

&

: ClassDecl->

()) {

(

.isVirtual())

(

*Field : ClassDecl->

()) {

(Field->isUnnamedBitField())

NumIdealInits = IdealInitKeys.size();

IdealIndex = 0;

(

InitIndex = 0; InitIndex != Inits.size(); ++InitIndex) {

(; IdealIndex != NumIdealInits; ++IdealIndex)

(InitKey == IdealInitKeys[IdealIndex])

(IdealIndex == NumIdealInits && InitIndex) {

WarnIndexes.push_back(InitIndex);

(IdealIndex = 0; IdealIndex != NumIdealInits; ++IdealIndex)

(InitKey == IdealInitKeys[IdealIndex])

assert(IdealIndex < NumIdealInits &&

);

CorrelatedInitOrder.emplace_back(IdealIndex, InitIndex);

(WarnIndexes.empty())

llvm::sort(CorrelatedInitOrder, llvm::less_first());

Inits[WarnIndexes.front() - 1]->getSourceLocation(),

WarnIndexes.size() == 1 ? diag::warn_initializer_out_of_order

: diag::warn_some_initializers_out_of_order);

(

I = 0; I < CorrelatedInitOrder.size(); ++I) {

(CorrelatedInitOrder[I].second == I)

Inits[I]->getSourceRange(),

Inits[CorrelatedInitOrder[I].second]->getSourceRange()),

(WarnIndexes.size() == 1) {

Inits[WarnIndexes.front()]);

(

WarnIndex : WarnIndexes) {

diag::note_initializer_out_of_order);

CheckRedundantInit(

&S,

S.

(

->getSourceLocation(),

diag::err_multiple_mem_initialization)

<<

->getDeclName()

<<

->getSourceRange();

*BaseClass =

->getBaseClass();

assert(BaseClass &&

);

S.

(

->getSourceLocation(),

diag::err_multiple_base_initialization)

<<

->getSourceRange();

std::pair<NamedDecl *, CXXCtorInitializer *> UnionEntry;

llvm::DenseMap<RecordDecl*, UnionEntry> RedundantUnionMap;

CheckRedundantUnionInit(

&S,

RedundantUnionMap &Unions) {

(

->isAnonymousStructOrUnion() ||

->isUnion()) {

(

->isUnion()) {

UnionEntry &En = Unions[

];

(En.first && En.first != Child) {

S.

(

->getSourceLocation(),

diag::err_multiple_mem_union_initialization)

<<

->getDeclName()

<<

->getSourceRange();

S.

(En.second->getSourceLocation(), diag::note_previous_initializer)

<< 0 << En.second->getSourceRange();

(!

->isAnonymousStructOrUnion())

(!ConstructorDecl)

= dyn_cast<CXXConstructorDecl>(ConstructorDecl);

(ColonLoc, diag::err_only_constructors_take_base_inits);

llvm::DenseMap<const void *, CXXCtorInitializer *> Members;

RedundantUnionMap MemberUnions;

HadError =

;

(

i = 0; i < MemInits.size(); i++) {

->setSourceOrder(i);

(

->isAnyMemberInitializer()) {

(CheckRedundantInit(*

,

, Members[Key]) ||

CheckRedundantUnionInit(*

,

, MemberUnions))

}

(

->isBaseInitializer()) {

(CheckRedundantInit(*

,

, Members[Key]))

assert(

->isDelegatingInitializer());

(MemInits.size() != 1) {

diag::err_delegating_initializer_alone)

<<

->getSourceRange() << MemInits[i ? 0 : 1]->getSourceRange();

DiagnoseUninitializedFields(*

, Constructor);

(

*Field : ClassDecl->

()) {

(Field->isInvalidDecl())

(diag::err_access_dtor_field)

<< Field->getDeclName()

VisitVirtualBases = !ClassDecl->

();

(Dtor && Dtor->

())

VisitVirtualBases =

;

(

&

: ClassDecl->

()) {

(

.isVirtual()) {

(!VisitVirtualBases)

DirectVirtualBases.insert(RT);

(diag::err_access_dtor_base)

<<

.getType() <<

.getSourceRange(),

(VisitVirtualBases)

&DirectVirtualBases);

llvm::SmallPtrSetImpl<const RecordType *> *DirectVirtualBases) {

(

&VBase : ClassDecl->

()) {

(DirectVirtualBases && DirectVirtualBases->count(RT))

(diag::err_access_dtor_vbase)

diag::err_access_dtor_vbase, 0, ClassDecl->

(),

= dyn_cast<CXXConstructorDecl>(CDtorDecl)) {

!ClassDecl || ClassDecl->isInvalidDecl()) {

DiagnoseUninitializedFields(*

, Constructor);

(CXXFinalOverriderMap::iterator M = FinalOverriders.begin(),

MEnd = FinalOverriders.end();

SOEnd = M->second.end();

SO != SOEnd; ++SO) {

(SO->second.size() != 1)

(!SO->second.front().Method->isPureVirtual())

(!SeenPureMethods.insert(SO->second.front().Method).second)

(SO->second.front().Method->getLocation(),

diag::note_pure_virtual_function)

<< SO->second.front().Method->getDeclName() << RD->

();

AbstractUsageInfo {

AbstractType(S.Context.getCanonicalType(

S.Context.getTypeDeclType(

))),

DiagnoseAbstractType() {

CheckAbstractUsage {

AbstractUsageInfo &Info;

CheckAbstractUsage(AbstractUsageInfo &Info,

*Ctx)

: Info(Info), Ctx(Ctx) {}

(

I = 0,

= TL.

(); I !=

; ++I) {

Visit(Next, Sel);

= Info.S.Context.getBaseElementType(

);

(CT != Info.AbstractType)

;

Info.S.Diag(Ctx->getLocation(), diag::err_array_of_abstract_type)

Info.S.Diag(Ctx->getLocation(), diag::err_abstract_type_in_decl)

Info.DiagnoseAbstractType();

CheckAbstractUsage(*

,

).Visit(TL, Sel);

(

*

: RD->

()) {

(

*FD = dyn_cast<FriendDecl>(

)) {

= FD->getFriendDecl();

(!

)

;

(

*FD = dyn_cast<FunctionDecl>(

)) {

}

(

*FTD = dyn_cast<FunctionTemplateDecl>(

)) {

}

(

*FD = dyn_cast<FieldDecl>(

)) {

}

(

*VD = dyn_cast<VarDecl>(

)) {

}

(

*VTD = dyn_cast<VarTemplateDecl>(

)) {

}

(

*RD = dyn_cast<CXXRecordDecl>(

)) {

}

(

*CTD = dyn_cast<ClassTemplateDecl>(

)) {

assert(ClassAttr->

() == attr::DLLExport);

MarkingClassDllexported {

Ctx.PointOfInstantiation = AttrLoc;

Ctx.Entity =

;

~MarkingClassDllexported() {

(!

->hasAttr<DLLExportAttr>())

*VD = dyn_cast<VarDecl>(

);

(VD && VD->getStorageClass() ==

&&

*MD = dyn_cast<CXXMethodDecl>(

);

(MD->isUserProvided()) {

*CD = dyn_cast<CXXConstructorDecl>(MD);

(CD && CD->isDefaultConstructor() && TSK ==

) {

}

(MD->isExplicitlyDefaulted()) {

}

(!MD->isTrivial() ||

MD->isCopyAssignmentOperator() ||

MD->isMoveAssignmentOperator()) {

*CD = dyn_cast<CXXConstructorDecl>(

);

(!CD || !CD->isDefaultConstructor())

*

= CD->getAttr<DLLExportAttr>();

(!

->isDependentContext()) {

(LastExportedDefaultCtor) {

diag::err_attribute_dll_ambiguous_default_ctor)

S.

(CD->getLocation(), diag::note_entity_declared_at)

<< CD->getDeclName();

LastExportedDefaultCtor = CD;

ErrorReported =

;

reportIllegalClassTemplate = [&ErrorReported](

&S,

S.

(TD->getLocation(),

diag::err_cuda_device_builtin_surftex_cls_template)

ErrorReported =

;

*SD = dyn_cast<ClassTemplateSpecializationDecl>(

);

diag::err_cuda_device_builtin_surftex_ref_decl)

diag::note_cuda_device_builtin_surftex_should_be_template_class)

TD = SD->getSpecializedTemplate();

N = Params->

();

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)

(N > 0 && !isa<TemplateTypeParmDecl>(Params->

(0))) {

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)

*NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->

(1));

(!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)

ErrorReported =

;

reportIllegalClassTemplate = [&ErrorReported](

&S,

S.

(TD->getLocation(),

diag::err_cuda_device_builtin_surftex_cls_template)

ErrorReported =

;

*SD = dyn_cast<ClassTemplateSpecializationDecl>(

);

diag::err_cuda_device_builtin_surftex_ref_decl)

diag::note_cuda_device_builtin_surftex_should_be_template_class)

TD = SD->getSpecializedTemplate();

N = Params->

();

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_n_args)

(N > 0 && !isa<TemplateTypeParmDecl>(Params->

(0))) {

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)

*NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->

(1));

(!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)

*NTTP = dyn_cast<NonTypeTemplateParmDecl>(Params->

(2));

(!NTTP || !NTTP->getType()->isIntegralOrEnumerationType()) {

reportIllegalClassTemplate(S, TD);

diag::note_cuda_device_builtin_surftex_cls_should_have_match_arg)

(

*Method :

->methods()) {

(Method->isUserProvided())

(

*Spec = dyn_cast<ClassTemplatePartialSpecializationDecl>(

)) {

(

*TemplateAttr =

(Spec->getSpecializedTemplate()->getTemplatedDecl())) {

*A = cast<InheritableAttr>(TemplateAttr->clone(

()));

A->setInherited(

);

(!

->isExternallyVisible() &&

->hasExternalFormalLinkage())) {

->dropAttrs<DLLExportAttr, DLLImportAttr>();

(!

->isExternallyVisible()) {

(

->getLocation(), diag::err_attribute_dll_not_extern)

<<

<< ClassAttr;

(!isa<VarDecl>(

) && !isa<CXXMethodDecl>(

))

diag::err_attribute_dll_member_of_dll_class)

<< MemberAttr << ClassAttr;

(ClassAttr->getLocation(), diag::note_previous_attribute);

->setInvalidDecl();

(

->getDescribedClassTemplate())

ClassExported = ClassAttr->

() == attr::DLLExport;

PropagatedImport =

cast<DLLImportAttr>(ClassAttr)->wasPropagatedToBaseTemplate();

(ClassExported && !ClassAttr->

() &&

->dropAttr<DLLExportAttr>();

*Ctor = dyn_cast<CXXConstructorDecl>(MD);

(Ctor || isa<CXXDestructorDecl>(MD)) && MD->

())

(VD && PropagatedImport)

(ClassExported) {

->addAttr(NewAttr);

);

NewAttr->setInherited(

);

BaseTemplateSpec->

(NewAttr);

(

*ImportAttr = dyn_cast<DLLImportAttr>(NewAttr))

ImportAttr->setPropagatedToBaseTemplate();

(BaseLoc, diag::warn_attribute_dll_instantiated_base_class)

diag::note_template_class_explicit_specialization_was_here)

<< BaseTemplateSpec;

diag::note_template_class_instantiation_was_here)

<< BaseTemplateSpec;

(

*MD = dyn_cast<CXXMethodDecl>(FD)) {

(MD->isCopyAssignmentOperator())

(MD->isMoveAssignmentOperator())

(isa<CXXDestructorDecl>(FD))

OO_ExclaimEqual:

OO_GreaterEqual:

cast<CXXConstructorDecl>(FD));

llvm_unreachable(

);

!

->hasNonTrivialDestructorForCall() &&

!

->hasNonTrivialCopyConstructorForCall();

CopyCtorIsTrivial =

, CopyCtorIsTrivialForCall =

;

DtorIsTrivialForCall =

;

(

->needsImplicitCopyConstructor()) {

(!

->defaultedCopyConstructorIsDeleted()) {

(

->hasTrivialCopyConstructor())

CopyCtorIsTrivial =

;

(

->hasTrivialCopyConstructorForCall())

CopyCtorIsTrivialForCall =

;

(CD->isCopyConstructor() && !CD->isDeleted() &&

!CD->isIneligibleOrNotSelected()) {

(CD->isTrivial())

CopyCtorIsTrivial =

;

(CD->isTrivialForCall())

CopyCtorIsTrivialForCall =

;

(

->needsImplicitDestructor()) {

(!

->defaultedDestructorIsDeleted() &&

->hasTrivialDestructorForCall())

DtorIsTrivialForCall =

;

}

(

*DD =

->getDestructor()) {

(!DD->isDeleted() && DD->isTrivialForCall())

DtorIsTrivialForCall =

;

(CopyCtorIsTrivialForCall && DtorIsTrivialForCall)

uint64_t TypeSize = isAArch64 ? 128 : 64;

(CopyCtorIsTrivial &&

HasNonDeletedCopyOrMove =

;

(

->needsImplicitCopyConstructor() &&

!

->defaultedCopyConstructorIsDeleted()) {

(!

->hasTrivialCopyConstructorForCall())

HasNonDeletedCopyOrMove =

;

(S.

().CPlusPlus11 &&

->needsImplicitMoveConstructor() &&

!

->defaultedMoveConstructorIsDeleted()) {

(!

->hasTrivialMoveConstructorForCall())

HasNonDeletedCopyOrMove =

;

(

->needsImplicitDestructor() && !

->defaultedDestructorIsDeleted() &&

!

->hasTrivialDestructorForCall())

(MD->isDeleted() || MD->isIneligibleOrNotSelected())

*CD = dyn_cast<CXXConstructorDecl>(MD);

(CD && CD->isCopyOrMoveConstructor())

HasNonDeletedCopyOrMove =

;

(!isa<CXXDestructorDecl>(MD))

(!MD->isTrivialForCall())

HasNonDeletedCopyOrMove;

IssuedDiagnostic =

;

(!IssuedDiagnostic) {

IssuedDiagnostic =

;

S.

(O->getLocation(), diag::note_overridden_virtual_function);

IssuedDiagnostic;

(

->isAbstract() && !

->isInvalidDecl()) {

AbstractUsageInfo Info(*

,

);

(!

->isInvalidDecl() && !

->isDependentType() &&

!

->isAggregate() && !

->hasUserDeclaredConstructor() &&

Complained =

;

(

*F :

->fields()) {

(F->hasInClassInitializer() || F->isUnnamedBitField())

(F->getType()->isReferenceType() ||

(F->getType().isConstQualified() && F->getType()->isScalarType())) {

(

->getLocation(), diag::warn_no_constructor_for_refconst)

<< llvm::to_underlying(

->getTagKind()) <<

;

(F->getLocation(), diag::note_refconst_member_not_initialized)

<< F->getType()->isReferenceType()

<< F->getDeclName();

(

->getIdentifier()) {

(((isa<FieldDecl>(

) || isa<UnresolvedUsingValueDecl>(

)) &&

->hasUserDeclaredConstructor()) ||

isa<IndirectFieldDecl>(

)) {

((*I)->getLocation(), diag::err_member_name_of_class)

<<

->getDeclName();

(

->isPolymorphic() && !

->isDependentType()) {

!

->hasAttr<FinalAttr>())

(

->isAbstract()) {

(FinalAttr *FA =

->getAttr<FinalAttr>()) {

(

->getLocation(), diag::warn_abstract_final_class)

<< FA->isSpelledAsSealed();

(!

->hasAttr<FinalAttr>()) {

(

FinalAttr *FA = dtor->getAttr<FinalAttr>()) {

(FA->getLocation(), diag::warn_final_dtor_non_final_class)

<< FA->isSpelledAsSealed()

(FA->isSpelledAsSealed() ?

:

));

diag::note_final_dtor_non_final_class_silence)

(

->hasAttr<TrivialABIAttr>())

HasTrivialABI =

->hasAttr<TrivialABIAttr>();

->setHasTrivialSpecialMemberForCall();

CheckCompletedMemberFunction = [&](

*MD) {

(

(*

, diag::err_static_overrides_virtual, MD,

MD->

() ? diag::err_deleted_override

: diag::err_non_deleted_override,

(MD->isDefaulted() && MD->isDeleted())

MD->isConsteval() ? diag::err_consteval_override

: diag::err_non_consteval_override,

MD->isConsteval() !=

->isConsteval();

(MD->isDefaulted() && MD->isDeleted())

CheckForDefaultedFunction = [&](

*FD) ->

{

(!FD || FD->

() || !FD->isExplicitlyDefaulted())

DefaultedSecondaryComparisons.push_back(FD);

(!

->isInvalidDecl() &&

->hasAttr<VTablePointerAuthenticationAttr>())

= CheckForDefaultedFunction(M);

(

->isDependentType())

(!M->isImplicit() && !M->isUserProvided()) {

->finishedDefaultedOrDeletedMember(M);

M->setTrivialForCall(

->setTrivialForCallFlags(M);

M->isUserProvided()) {

M->setTrivialForCall(HasTrivialABI);

->setTrivialForCallFlags(M);

(!M->isInvalidDecl() && M->isExplicitlyDefaulted() &&

M->hasAttr<DLLExportAttr>()) {

M->dropAttr<DLLExportAttr>();

(M->hasAttr<DLLExportAttr>()) {

EffectivelyConstexprDestructor =

;

(isa<CXXDestructorDecl>(M)) {

Check = [](

,

&&Check) ->

{

CanUnqualT =

.getCanonicalType().getUnqualifiedType();

(B.getType().getCanonicalType().getUnqualifiedType() !=

!Check(B.getType(), Check))

!Check(FD->

(), Check))

EffectivelyConstexprDestructor =

M->isDefaulted() && M->isConstexpr() && M->size_overridden_methods() &&

EffectivelyConstexprDestructor)

CheckCompletedMemberFunction(M);

CompleteMemberFunction(Dtor);

HasMethodWithOverrideControl =

,

HasOverridingMethodWithoutOverrideControl =

;

(

*

:

->decls()) {

(

*M = dyn_cast<CXXMethodDecl>(

)) {

(!

->isDependentType()) {

(M->hasAttr<OverrideAttr>())

HasMethodWithOverrideControl =

;

(M->size_overridden_methods() > 0)

HasOverridingMethodWithoutOverrideControl =

;

(!isa<CXXDestructorDecl>(M))

CompleteMemberFunction(M);

}

(

*F = dyn_cast<FriendDecl>(

)) {

CheckForDefaultedFunction(

dyn_cast_or_null<FunctionDecl>(F->getFriendDecl()));

(HasOverridingMethodWithoutOverrideControl) {

HasInconsistentOverrideControl = HasMethodWithOverrideControl;

(

*M :

->methods())

(

*FD : DefaultedSecondaryComparisons) {

(

*MD = dyn_cast<CXXMethodDecl>(FD))

CheckCompletedMemberFunction(MD);

(

->isPolymorphic() ||

->getNumBases())) {

(

->getLocation(), diag::warn_cxx_ms_struct);

ClangABICompat4 =

(

->getArgPassingRestrictions() !=

->setArgPassingRestrictions(

->setParamDestroyedInCallee(

);

(

->hasNonTrivialDestructor())

->setParamDestroyedInCallee(CanPass);

(

->hasAttr<CUDADeviceBuiltinSurfaceTypeAttr>())

(

->hasAttr<CUDADeviceBuiltinTextureTypeAttr>())

LHSQuals = 0;

LHSQuals = FieldQuals;

RHSQuals = FieldQuals;

llvm::DenseMap<CXXRecordDecl *, ConstructorUsingShadowDecl *>

: S(S), UseLoc(UseLoc) {

DiagnosedMultipleConstructedBases =

;

(

*

: Shadow->

()) {

*DShadow = cast<ConstructorUsingShadowDecl>(

);

*DNominatedBase = DShadow->getNominatedBaseClass();

*DConstructedBase = DShadow->getConstructedBaseClass();

InheritedFromBases.insert(

std::make_pair(DNominatedBase->getCanonicalDecl(),

DShadow->getNominatedBaseClassShadowDecl()));

(DShadow->constructsVirtualBase())

InheritedFromBases.insert(

std::make_pair(DConstructedBase->getCanonicalDecl(),

DShadow->getConstructedBaseClassShadowDecl()));

assert(DNominatedBase == DConstructedBase);

(!ConstructedBase) {

ConstructedBase = DConstructedBase;

ConstructedBaseIntroducer =

->getIntroducer();

}

(ConstructedBase != DConstructedBase &&

(!DiagnosedMultipleConstructedBases) {

S.

(UseLoc, diag::err_ambiguous_inherited_constructor)

diag::note_ambiguous_inherited_constructor_using)

DiagnosedMultipleConstructedBases =

;

diag::note_ambiguous_inherited_constructor_using)

<< DConstructedBase;

(DiagnosedMultipleConstructedBases)

std::pair<CXXConstructorDecl *, bool>

It = InheritedFromBases.find(

->getCanonicalDecl());

(It == InheritedFromBases.end())

std::make_pair(

,

);

std::make_pair(

It->second->constructsVirtualBase());

std::make_pair(Ctor,

);

(InheritedCtor) {

Inherited->findConstructorForBase(ClassDecl, InheritedCtor).first;

BaseCtor->isConstexpr();

(Ctor && ClassDecl->

())

(

&B : ClassDecl->

()) {

InheritedCtor, Inherited))

(

*F : ClassDecl->

()) {

(F->isInvalidDecl())

F->hasInClassInitializer())

*FieldRecDecl = cast<CXXRecordDecl>(RecordTy->getDecl());

ConstArg && !F->isMutable()))

ComputingExceptionSpec {

Ctx.PointOfInstantiation =

;

~ComputingExceptionSpec() {

(DFK.isSpecialMember())

S,

, cast<CXXMethodDecl>(FD), DFK.asSpecialMember(),

);

(DFK.isComparison())

DFK.asComparison());

*CD = cast<CXXConstructorDecl>(FD);

assert(CD->getInheritedConstructor() &&

);

S,

, CD->getInheritedConstructor().getShadowDecl());

ESI = IES.getExceptionSpec();

PT.getNonReferenceType()->getAsCXXRecordDecl()) {

);

HadError =

;

ShouldDeleteForTypeMismatch =

;

ExpectedParams = 1;

(DeleteOnTypeMismatch)

ShouldDeleteForTypeMismatch =

;

(MD->

(), diag::err_defaulted_special_member_variadic)

CanHaveConstParam =

;

ReturnType =

->getReturnType();

DeclType,

);

(MD->

(), diag::err_defaulted_special_member_return_type)

<< ExpectedReturnType;

(DeleteOnTypeMismatch)

ShouldDeleteForTypeMismatch =

;

(!ExplicitObjectParameter.

() &&

(DeleteOnTypeMismatch)

ShouldDeleteForTypeMismatch =

;

diag::err_defaulted_special_member_explicit_object_mismatch)

HasConstParam =

;

(DeleteOnTypeMismatch)

ShouldDeleteForTypeMismatch =

;

diag::err_defaulted_special_member_volatile_param)

<< llvm::to_underlying(CSM);

(HasConstParam && !CanHaveConstParam) {

(DeleteOnTypeMismatch)

ShouldDeleteForTypeMismatch =

;

diag::err_defaulted_special_member_copy_const_param)

diag::err_defaulted_special_member_move_const_param)

}

(ExpectedParams) {

);

: isa<CXXConstructorDecl>(MD))) &&

diag::err_incorrect_defaulted_constexpr_with_vb)

<< llvm::to_underlying(CSM);

(

&I : RD->

())

(I.getBeginLoc(), diag::note_constexpr_virtual_base_here);

<< llvm::to_underlying(CSM) << MD->

();

(!

->hasExceptionSpec()) {

<< llvm::to_underlying(CSM);

(ShouldDeleteForTypeMismatch) {

<< llvm::to_underlying(CSM);

(DefaultLoc, diag::note_replace_equals_default_to_delete)

(ShouldDeleteForTypeMismatch && !HadError) {

diag::warn_cxx17_compat_defaulted_method_type_mismatch)

<< llvm::to_underlying(CSM);

<< llvm::to_underlying(CSM);

assert(!ShouldDeleteForTypeMismatch &&

);

<

Derived,

ResultList,

,

DefaultedComparisonVisitor {

DefaultedComparisonKind DCK)

: S(S), RD(RD), FD(FD), DCK(DCK) {

Fns.assign(Info->getUnqualifiedLookups().begin(),

Info->getUnqualifiedLookups().end());

ResultList visit() {

DefaultedComparisonKind::None:

llvm_unreachable(

);

DefaultedComparisonKind::Equal:

DefaultedComparisonKind::ThreeWay:

getDerived().visitSubobjects(Results, RD, ParamLvalType.

());

DefaultedComparisonKind::NotEqual:

DefaultedComparisonKind::Relational:

Results.add(getDerived().visitExpandedSubobject(

ParamLvalType, getDerived().getCompleteObject()));

llvm_unreachable(

);

Derived &getDerived() {

Derived&

(*this); }

(Results.add(getDerived().visitSubobject(

getDerived().getBase(&

))))

(

->isUnnamedBitField())

(

->isAnonymousStructOrUnion()) {

(visitSubobjects(Results,

->getType()->getAsCXXRecordDecl(),

(

->isMutable())

(Results.add(getDerived().visitSubobject(

FieldType, getDerived().getField(Field))))

Result visitSubobject(

, Subobject Subobj) {

(

*CAT = dyn_cast_or_null<ConstantArrayType>(AT))

getDerived().visitSubobjectArray(CAT->getElementType(),

CAT->getSize(), Subobj);

getDerived().visitExpandedSubobject(

, Subobj);

Result visitSubobjectArray(

,

llvm::APInt &Size,

getDerived().visitSubobject(

, Subobj);

DefaultedComparisonKind DCK;

DefaultedComparisonInfo {

DefaultedComparisonInfo deleted() {

DefaultedComparisonInfo

;

add(

DefaultedComparisonInfo &R) {

DefaultedComparisonSubobject {

DefaultedComparisonAnalyzer

:

DefaultedComparisonVisitor<DefaultedComparisonAnalyzer,

DefaultedComparisonInfo,

DefaultedComparisonInfo,

DefaultedComparisonSubobject> {

DiagnosticKind { NoDiagnostics, ExplainDeleted, ExplainConstexpr };

DiagnosticKind Diagnose;

= DefaultedComparisonVisitor;

Result = DefaultedComparisonInfo;

Subobject = DefaultedComparisonSubobject;

DefaultedComparisonKind DCK,

DiagnosticKind Diagnose = NoDiagnostics)

:

(S, RD, FD, DCK), Diagnose(Diagnose) {}

((DCK == DefaultedComparisonKind::Equal ||

DCK == DefaultedComparisonKind::ThreeWay) &&

(Diagnose == ExplainDeleted) {

<< FD << RD->

() << RD;

Result::deleted();

Base::visit();

Subobject getCompleteObject() {

Subobject{Subobject::CompleteObject, RD, FD->

()};

Subobject{Subobject::Base,

->getType()->getAsCXXRecordDecl(),

->getBaseTypeLoc()};

Subobject{Subobject::Member,

,

->getLocation()};

Result visitExpandedSubobject(

, Subobject Subobj) {

(Diagnose == ExplainDeleted) {

S.

(Subobj.Loc, diag::note_defaulted_comparison_reference_member)

Result::deleted();

*Args[] = {&Xi, &Xi};

assert(OO !=

&&

);

visitBinaryOperator(OO, Args, Subobj);

!SpaceshipCandidates));

CandidateSet.exclude(FD);

(Args[0]->getType()->isOverloadableType())

(CandidateSet.BestViableFunction(S, FD->

(), Best)) {

((DCK == DefaultedComparisonKind::NotEqual ||

DCK == DefaultedComparisonKind::Relational) &&

!Best->RewriteKind) {

(Diagnose == ExplainDeleted) {

(Best->Function) {

S.

(Best->Function->getLocation(),

diag::note_defaulted_comparison_not_rewritten_callee)

assert(Best->Conversions.size() == 2 &&

Best->Conversions[0].isUserDefined() &&

S.

(Best->Conversions[0]

.UserDefined.FoundConversionFunction.getDecl()

diag::note_defaulted_comparison_not_rewritten_conversion)

Result::deleted();

*ArgClass = Args[0]->getType()->getAsCXXRecordDecl();

(ArgClass && Best->FoundDecl.getDecl() &&

Best->FoundDecl.getDecl()->isCXXClassMember()) {

ObjectType = Subobj.Kind == Subobject::Member

? Args[0]->getType()

ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc,

Diagnose == ExplainDeleted

? S.

(diag::note_defaulted_comparison_inaccessible)

<< FD << Subobj.Kind << Subobj.Decl

Result::deleted();

NeedsDeducing =

assert(!BestFD->isDeleted() &&

);

(Diagnose == ExplainConstexpr && !BestFD->isConstexpr()) {

(Subobj.Kind != Subobject::CompleteObject)

S.

(Subobj.Loc, diag::note_defaulted_comparison_not_constexpr)

<< Subobj.

<< Subobj.Decl;

S.

(BestFD->getLocation(),

diag::note_defaulted_comparison_not_constexpr_here);

Result::deleted();

R.Constexpr &= BestFD->isConstexpr();

(NeedsDeducing) {

(BestFD->getReturnType()->isUndeducedType() &&

(Diagnose == NoDiagnostics) {

diag::err_defaulted_comparison_cannot_deduce_undeduced_auto)

<< Subobj.

<< Subobj.Decl;

diag::note_defaulted_comparison_cannot_deduce_undeduced_auto)

<< Subobj.

<< Subobj.Decl;

S.

(BestFD->getLocation(),

diag::note_defaulted_comparison_cannot_deduce_callee)

<< Subobj.

<< Subobj.Decl;

Result::deleted();

BestFD->getCallResultType());

(Diagnose == ExplainDeleted) {

S.

(Subobj.Loc, diag::note_defaulted_comparison_cannot_deduce)

<< Subobj.

<< Subobj.Decl

<< BestFD->getCallResultType().withoutLocalFastQualifiers();

S.

(BestFD->getLocation(),

diag::note_defaulted_comparison_cannot_deduce_callee)

<< Subobj.

<< Subobj.Decl;

Result::deleted();

R.Category = Info->Kind;

= Best->BuiltinParamTypes[0];

assert(

== Best->BuiltinParamTypes[1] &&

);

assert(Best->BuiltinParamTypes[2].isNull() &&

);

(NeedsDeducing) {

std::optional<ComparisonCategoryType> Cat =

assert(Cat &&

);

(Diagnose == ExplainDeleted) {

= OO == OO_EqualEqual ? 1 : 2;

CandidateSet.NoteCandidates(

Subobj.Loc, S.

(diag::note_defaulted_comparison_ambiguous)

<< FD <<

<< Subobj.Kind << Subobj.Decl),

R = Result::deleted();

(Diagnose == ExplainDeleted) {

((DCK == DefaultedComparisonKind::NotEqual ||

DCK == DefaultedComparisonKind::Relational) &&

!Best->RewriteKind) {

S.

(Best->Function->getLocation(),

diag::note_defaulted_comparison_not_rewritten_callee)

S.

(Subobj.Loc,

diag::note_defaulted_comparison_calls_deleted)

<< FD << Subobj.

<< Subobj.Decl;