Lines Matching refs:Base
920 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
924 return S.CreateBuiltinArraySubscriptExpr(Base, Loc, E.get(), Loc);
953 [&](SourceLocation Loc, Expr *Base, unsigned I) -> ExprResult {
954 return S.CreateBuiltinUnaryOp(Loc, I ? UO_Imag : UO_Real, Base);
1299 else if (!S.Context.hasSameType(P.back().Base->getType(),
1300 BestPath->back().Base->getType())) {
1303 << false << RD << BestPath->back().Base->getType()
1304 << P.back().Base->getType();
1312 QualType BaseType = BestPath->back().Base->getType();
1334 << Paths.front().back().Base->getType();
2234 // Check initialization of non-static data members. Base classes are
2395 CXXRecordDecl *Base = I.getType()->getAsCXXRecordDecl();
2396 if (!Base)
2399 Base = Base->getDefinition();
2400 if (!Base)
2403 if (Base->getCanonicalDecl() == Class)
2406 Queue.push_back(Base);
2474 // Base specifiers must be record types.
2511 assert(BaseDecl && "Base type is not incomplete, but has no definition");
2513 assert(CXXBaseDecl && "Base type is not a C++ type");
2628 QualType Base = Context.getCanonicalType(BaseSpec.getType())
2630 if (Set.insert(Base).second)
2632 NoteIndirectBases(Context, Set, Base);
2755 /// derived from the type \p Base.
2756 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base) {
2764 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2782 /// derived from the type \p Base.
2783 bool Sema::IsDerivedFrom(SourceLocation Loc, QualType Derived, QualType Base,
2792 CXXRecordDecl *BaseRD = Base->getAsCXXRecordDecl();
2809 if (Path[I - 1].Base->isVirtual()) {
2817 BasePathArray.push_back(const_cast<CXXBaseSpecifier*>(Path[I].Base));
2823 assert(BasePathArray.empty() && "Base path array must be empty!");
2827 /// CheckDerivedToBaseConversion - Check whether the Derived-to-Base
2828 /// conversion (where Derived and Base are class types) is
2840 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2847 // First, determine whether the path from Derived to Base is
2849 // the Derived to Base conversion exists, because here we need to
2853 bool DerivationOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2858 if (!Paths.isAmbiguous(Context.getCanonicalType(Base).getUnqualifiedType()))
2861 // For MSVC compatibility, check if Derived directly inherits from Base. Clang
2870 << Base << Derived << Range;
2880 CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) {
2905 bool StillOkay = IsDerivedFrom(Loc, Derived, Base, Paths);
2916 << Derived << Base << PathDisplayStr << Range << Name;
2922 Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base,
2927 Derived, Base, diag::err_upcast_to_inaccessible_base,
2957 PathDisplayStr += " -> " + Element->Base->getType().getAsString();
3131 const auto Base = Specifier->getType()->getAsCXXRecordDecl();
3133 if (Bases.find(Base) != Bases.end())
3135 for (const auto Field : Base->lookup(FieldName)) {
3139 assert(Bases.find(Base) == Bases.end());
3140 Bases[Base] = Field;
3153 auto Base = P.back().Base->getType()->getAsCXXRecordDecl();
3154 auto It = Bases.find(Base);
3163 << FieldName << RD << Base << DeclIsField;
3563 Expr *Base = ME;
3565 dyn_cast<MemberExpr>(Base->IgnoreParenImpCasts())) {
3577 Base = SubME->getBase();
3580 if (!isa<CXXThisExpr>(Base->IgnoreParenImpCasts()))
3588 if (ImplicitCastExpr *BaseCast = dyn_cast<ImplicitCastExpr>(Base)) {
3981 for (const auto &Base : ClassDecl->bases()) {
3982 if (SemaRef.Context.hasSameUnqualifiedType(BaseType, Base.getType())) {
3985 DirectBaseSpec = &Base;
4004 if (Path->back().Base->isVirtual()) {
4005 VirtualBaseSpec = Path->back().Base;
5089 for (auto &Base : ClassDecl->bases()) {
5091 if (Base.isVirtual())
5095 = Info.AllBaseFields.lookup(Base.getType()->getAs<RecordType>())) {
5100 &Base, /*IsInheritedVirtualBase=*/false,
5224 for (const auto &Base : ClassDecl->bases()) {
5225 if (Base.isVirtual())
5227 IdealInitKeys.push_back(GetKeyForBase(SemaRef.Context, Base.getType()));
5480 for (const auto &Base : ClassDecl->bases()) {
5482 const RecordType *RT = Base.getType()->getAs<RecordType>();
5485 if (Base.isVirtual()) {
5502 CheckDestructorAccess(Base.getBeginLoc(), Dtor,
5504 << Base.getType() << Base.getSourceRange(),
6929 findConstructorForBase(CXXRecordDecl *Base, CXXConstructorDecl *Ctor) const {
6930 auto It = InheritedFromBases.find(Base->getCanonicalDecl());
7448 for (CXXBaseSpecifier &Base : Record->bases())
7450 S.Context.getQualifiedType(Base.getType(), Quals),
7451 getDerived().getBase(&Base))))
7526 enum { CompleteObject, Member, Base } Kind;
7545 using Base = DefaultedComparisonVisitor;
7549 friend Base;
7554 : Base(S, RD, FD, DCK), Diagnose(Diagnose) {}
7570 return Base::visit();
7578 Subobject getBase(CXXBaseSpecifier *Base) {
7579 return Subobject{Subobject::Base, Base->getType()->getAsCXXRecordDecl(),
7580 Base->getBaseTypeLoc()};
7848 using Base = DefaultedComparisonVisitor;
7851 friend Base;
7856 : Base(S, RD, FD, DCK), Loc(BodyLoc) {}
7984 ExprPair getBase(CXXBaseSpecifier *Base) {
7988 CXXCastPath Path = {Base};
7989 return {S.ImpCastExprToType(Obj.first.get(), Base->getType(),
7991 S.ImpCastExprToType(Obj.second.get(), Base->getType(),
8698 bool visitBase(CXXBaseSpecifier *Base) { return shouldDeleteForBase(Base); }
8701 bool shouldDeleteForBase(CXXBaseSpecifier *Base);
8772 CXXBaseSpecifier *Base = Subobj.get<CXXBaseSpecifier*>();
8773 S.Diag(Base->getBeginLoc(),
8776 << Base->getType() << DiagKind << IsDtorCallInCtor
8855 bool SpecialMemberDeletionInfo::shouldDeleteForBase(CXXBaseSpecifier *Base) {
8856 CXXRecordDecl *BaseClass = Base->getType()->getAsCXXRecordDecl();
8866 // this is the same as shouldDeleteForSubobjectCall(Base, BaseCtor, false);
8870 S.Diag(Base->getBeginLoc(),
8873 << Base->getType() << /*Deleted*/ 1 << /*IsDtorCallInCtor*/ false
8879 return shouldDeleteForClassSubobject(BaseClass, Base, 0);
11076 CXXRecordDecl *Base = BaseSpec.getType()->getAsCXXRecordDecl();
11078 if (Base->isEmpty())
11685 static bool isVirtualDirectBase(CXXRecordDecl *Derived, CXXRecordDecl *Base) {
11689 if (B.getType()->getAsCXXRecordDecl() == Base)
11743 /// struct Base { void foo(int); };
11744 /// struct Derived : Base {
11745 /// using Base::foo;
11793 for (auto &Base : Derived->bases()) {
11794 CanQualType BaseType = Base.getType()->getCanonicalTypeUnqualified();
11796 return &Base;
11837 // type; we don't want to suggest 'using Derived::Base;', since that
12173 auto *Base = findDirectBaseWithType(TargetClass, QualType(SourceType, 0),
12175 if (!Base && !AnyDependentBases) {
12184 if (Base)
12185 Base->setInheritConstructors();
12429 auto Collect = [&Bases](const CXXRecordDecl *Base) {
12430 Bases.insert(Base);
12440 auto IsNotBase = [&Bases](const CXXRecordDecl *Base) {
12441 return !Bases.count(Base);
12704 bool visitBase(CXXBaseSpecifier *Base);
12715 bool SpecialMemberExceptionSpecInfo::visitBase(CXXBaseSpecifier *Base) {
12716 auto *RT = Base->getType()->getAs<RecordType>();
12723 visitSubobjectCall(Base, BaseCtor);
12727 visitClassSubobject(BaseClass, Base, 0);
13507 const ExprBuilder &Base;
13513 Base.build(S, Loc), Loc, Index.build(S, Loc), Loc).get());
13516 SubscriptBuilder(const ExprBuilder &Base, const ExprBuilder &Index)
13517 : Base(Base), Index(Index) {}
14012 for (auto &Base : ClassDecl->bases()) {
14014 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&>(other));
14015 QualType BaseType = Base.getType().getUnqualifiedType();
14022 BasePath.push_back(&Base);
14249 CXXRecordDecl *Base = BaseSpec->getType()->getAsCXXRecordDecl();
14253 if (!Base->hasNonTrivialMoveAssignment())
14257 if (!BaseSpec->isVirtual() && !Base->getNumVBases())
14263 S.LookupSpecialMember(Base, Sema::CXXMoveAssignment,
14278 VBases.insert(std::make_pair(Base->getCanonicalDecl(), &BI))
14282 << Class << Base;
14284 << (Base->getCanonicalDecl() ==
14286 << Base << Existing->getType() << Existing->getSourceRange();
14288 << (Base->getCanonicalDecl() ==
14290 << Base << BI.getType() << BaseSpec->getSourceRange();
14302 // We're going to move the base classes of Base. Add them to the list.
14303 for (auto &BI : Base->bases())
14372 for (auto &Base : ClassDecl->bases()) {
14382 // static_cast<Base*>(this)->Base::operator=(static_cast<Base&&>(other));
14383 QualType BaseType = Base.getType().getUnqualifiedType();
14390 BasePath.push_back(&Base);
17289 const auto *Base =
17291 if (Base->getNumVBases() == 0)
17293 MarkVirtualMembersReferenced(Loc, Base);