From 6c333167c186d95fdf4ff698288f1026da7b1fa3 Mon Sep 17 00:00:00 2001 From: Vlad Serebrennikov Date: Sun, 19 May 2024 00:50:32 +0300 Subject: [PATCH 1/4] [clang] Introduce `SemaAccess` --- clang/include/clang/Sema/Lookup.h | 3 +- clang/include/clang/Sema/Sema.h | 94 +-------- clang/include/clang/Sema/SemaAccess.h | 113 +++++++++++ clang/lib/Sema/Sema.cpp | 2 + clang/lib/Sema/SemaAccess.cpp | 182 +++++++++--------- clang/lib/Sema/SemaCast.cpp | 21 +- clang/lib/Sema/SemaCodeComplete.cpp | 5 +- clang/lib/Sema/SemaDecl.cpp | 3 +- clang/lib/Sema/SemaDeclAttr.cpp | 3 +- clang/lib/Sema/SemaDeclCXX.cpp | 31 +-- clang/lib/Sema/SemaDeclObjC.cpp | 3 +- clang/lib/Sema/SemaExceptionSpec.cpp | 11 +- clang/lib/Sema/SemaExprCXX.cpp | 23 +-- clang/lib/Sema/SemaExprMember.cpp | 1 + clang/lib/Sema/SemaInit.cpp | 17 +- clang/lib/Sema/SemaLookup.cpp | 5 +- clang/lib/Sema/SemaOpenMP.cpp | 9 +- clang/lib/Sema/SemaOverload.cpp | 27 +-- clang/lib/Sema/SemaTemplate.cpp | 3 +- .../lib/Sema/SemaTemplateInstantiateDecl.cpp | 7 +- 20 files changed, 312 insertions(+), 251 deletions(-) create mode 100644 clang/include/clang/Sema/SemaAccess.h diff --git a/clang/include/clang/Sema/Lookup.h b/clang/include/clang/Sema/Lookup.h index b0a08a05ac6a0..1d2a7de941698 100644 --- a/clang/include/clang/Sema/Lookup.h +++ b/clang/include/clang/Sema/Lookup.h @@ -25,6 +25,7 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Sema/Sema.h" +#include "clang/Sema/SemaAccess.h" #include "llvm/ADT/MapVector.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/Casting.h" @@ -761,7 +762,7 @@ class LookupResult { void diagnoseAccess() { if (!isAmbiguous() && isClassLookup() && getSema().getLangOpts().AccessControl) - getSema().CheckLookupAccess(*this); + getSema().Access().CheckLookupAccess(*this); } void diagnoseAmbiguous() { diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index d4d4a82525a02..0bbc20d1766e5 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -167,6 +167,7 @@ class Preprocessor; class PseudoDestructorTypeStorage; class PseudoObjectExpr; class QualType; +class SemaAccess; class SemaCodeCompletion; class SemaCUDA; class SemaHLSL; @@ -984,6 +985,11 @@ class Sema final : public SemaBase { /// CurContext - This is the current declaration context of parsing. DeclContext *CurContext; + SemaAccess &Access() { + assert(AccessPtr); + return *AccessPtr; + } + SemaCodeCompletion &CodeCompletion() { assert(CodeCompletionPtr); return *CodeCompletionPtr; @@ -1049,6 +1055,7 @@ class Sema final : public SemaBase { mutable IdentifierInfo *Ident_super; + std::unique_ptr AccessPtr; std::unique_ptr CodeCompletionPtr; std::unique_ptr CUDAPtr; std::unique_ptr HLSLPtr; @@ -1065,93 +1072,6 @@ class Sema final : public SemaBase { // // - /// \name C++ Access Control - /// Implementations are in SemaAccess.cpp - ///@{ - -public: - enum AccessResult { - AR_accessible, - AR_inaccessible, - AR_dependent, - AR_delayed - }; - - bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, - NamedDecl *PrevMemberDecl, - AccessSpecifier LexicalAS); - - AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, - DeclAccessPair FoundDecl); - AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, - DeclAccessPair FoundDecl); - AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, - SourceRange PlacementRange, - CXXRecordDecl *NamingClass, - DeclAccessPair FoundDecl, - bool Diagnose = true); - AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, - DeclAccessPair FoundDecl, - const InitializedEntity &Entity, - bool IsCopyBindingRefToTemp = false); - AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, - DeclAccessPair FoundDecl, - const InitializedEntity &Entity, - const PartialDiagnostic &PDiag); - AccessResult CheckDestructorAccess(SourceLocation Loc, - CXXDestructorDecl *Dtor, - const PartialDiagnostic &PDiag, - QualType objectType = QualType()); - AccessResult CheckFriendAccess(NamedDecl *D); - AccessResult CheckMemberAccess(SourceLocation UseLoc, - CXXRecordDecl *NamingClass, - DeclAccessPair Found); - AccessResult - CheckStructuredBindingMemberAccess(SourceLocation UseLoc, - CXXRecordDecl *DecomposedClass, - DeclAccessPair Field); - AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, - const SourceRange &, - DeclAccessPair FoundDecl); - AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, - Expr *ArgExpr, - DeclAccessPair FoundDecl); - AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, - ArrayRef ArgExprs, - DeclAccessPair FoundDecl); - AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, - DeclAccessPair FoundDecl); - AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, - QualType Derived, const CXXBasePath &Path, - unsigned DiagID, bool ForceCheck = false, - bool ForceUnprivileged = false); - void CheckLookupAccess(const LookupResult &R); - bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass, - QualType BaseType); - bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, - DeclAccessPair Found, QualType ObjectType, - SourceLocation Loc, - const PartialDiagnostic &Diag); - bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, - DeclAccessPair Found, - QualType ObjectType) { - return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType, - SourceLocation(), PDiag()); - } - - void HandleDependentAccessCheck( - const DependentDiagnostic &DD, - const MultiLevelTemplateArgumentList &TemplateArgs); - void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx); - - ///@} - - // - // - // ------------------------------------------------------------------------- - // - // - /// \name Attributes /// Implementations are in SemaAttr.cpp ///@{ diff --git a/clang/include/clang/Sema/SemaAccess.h b/clang/include/clang/Sema/SemaAccess.h new file mode 100644 index 0000000000000..280c41aa33124 --- /dev/null +++ b/clang/include/clang/Sema/SemaAccess.h @@ -0,0 +1,113 @@ +//===----- SemaAccess.h --------- C++ Access Control ----------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +/// \file +/// This file declares routines for C++ access control semantics. +/// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_CLANG_SEMA_SEMAACCESS_H +#define LLVM_CLANG_SEMA_SEMAACCESS_H + +#include "clang/AST/CXXInheritance.h" +#include "clang/AST/Decl.h" +#include "clang/AST/DeclAccessPair.h" +#include "clang/AST/DeclCXX.h" +#include "clang/AST/DependentDiagnostic.h" +#include "clang/AST/Expr.h" +#include "clang/AST/ExprCXX.h" +#include "clang/AST/Type.h" +#include "clang/Basic/LLVM.h" +#include "clang/Basic/PartialDiagnostic.h" +#include "clang/Basic/SourceLocation.h" +#include "clang/Basic/Specifiers.h" +#include "clang/Sema/DelayedDiagnostic.h" +#include "clang/Sema/Initialization.h" +#include "clang/Sema/SemaBase.h" + +namespace clang { +class LookupResult; +class MultiLevelTemplateArgumentList; + +class SemaAccess : public SemaBase { +public: + SemaAccess(Sema &S); + + enum AccessResult { + AR_accessible, + AR_inaccessible, + AR_dependent, + AR_delayed + }; + + bool SetMemberAccessSpecifier(NamedDecl *MemberDecl, + NamedDecl *PrevMemberDecl, + AccessSpecifier LexicalAS); + + AccessResult CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, + DeclAccessPair FoundDecl); + AccessResult CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, + DeclAccessPair FoundDecl); + AccessResult CheckAllocationAccess(SourceLocation OperatorLoc, + SourceRange PlacementRange, + CXXRecordDecl *NamingClass, + DeclAccessPair FoundDecl, + bool Diagnose = true); + AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, + DeclAccessPair FoundDecl, + const InitializedEntity &Entity, + bool IsCopyBindingRefToTemp = false); + AccessResult CheckConstructorAccess(SourceLocation Loc, CXXConstructorDecl *D, + DeclAccessPair FoundDecl, + const InitializedEntity &Entity, + const PartialDiagnostic &PDiag); + AccessResult CheckDestructorAccess(SourceLocation Loc, + CXXDestructorDecl *Dtor, + const PartialDiagnostic &PDiag, + QualType objectType = QualType()); + AccessResult CheckFriendAccess(NamedDecl *D); + AccessResult CheckMemberAccess(SourceLocation UseLoc, + CXXRecordDecl *NamingClass, + DeclAccessPair Found); + AccessResult + CheckStructuredBindingMemberAccess(SourceLocation UseLoc, + CXXRecordDecl *DecomposedClass, + DeclAccessPair Field); + AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, + const SourceRange &, + DeclAccessPair FoundDecl); + AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, + Expr *ArgExpr, + DeclAccessPair FoundDecl); + AccessResult CheckMemberOperatorAccess(SourceLocation Loc, Expr *ObjectExpr, + ArrayRef ArgExprs, + DeclAccessPair FoundDecl); + AccessResult CheckAddressOfMemberAccess(Expr *OvlExpr, + DeclAccessPair FoundDecl); + AccessResult CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, + QualType Derived, const CXXBasePath &Path, + unsigned DiagID, bool ForceCheck = false, + bool ForceUnprivileged = false); + void CheckLookupAccess(const LookupResult &R); + bool IsSimplyAccessible(NamedDecl *Decl, CXXRecordDecl *NamingClass, + QualType BaseType); + bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, + DeclAccessPair Found, QualType ObjectType, + SourceLocation Loc, + const PartialDiagnostic &Diag); + bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, + DeclAccessPair Found, + QualType ObjectType); + + void HandleDependentAccessCheck( + const DependentDiagnostic &DD, + const MultiLevelTemplateArgumentList &TemplateArgs); + void HandleDelayedAccessCheck(sema::DelayedDiagnostic &DD, Decl *Ctx); +}; +} // namespace clang + +#endif // LLVM_CLANG_SEMA_SEMAACCESS_H \ No newline at end of file diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index f847c49920cf3..0940885f12d19 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -41,6 +41,7 @@ #include "clang/Sema/RISCVIntrinsicManager.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaCodeCompletion.h" #include "clang/Sema/SemaConsumer.h" @@ -203,6 +204,7 @@ Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, LateTemplateParser(nullptr), LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), CurContext(nullptr), ExternalSource(nullptr), CurScope(nullptr), Ident_super(nullptr), + AccessPtr(std::make_unique(*this)), CodeCompletionPtr( std::make_unique(*this, CodeCompleter)), CUDAPtr(std::make_unique(*this)), diff --git a/clang/lib/Sema/SemaAccess.cpp b/clang/lib/Sema/SemaAccess.cpp index 979a64b065f3d..1e9958d845ba7 100644 --- a/clang/lib/Sema/SemaAccess.cpp +++ b/clang/lib/Sema/SemaAccess.cpp @@ -10,6 +10,7 @@ // //===----------------------------------------------------------------------===// +#include "clang/Sema/SemaAccess.h" #include "clang/AST/ASTContext.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/DeclCXX.h" @@ -37,7 +38,7 @@ enum AccessResult { /// SetMemberAccessSpecifier - Set the access specifier of a member. /// Returns true on error (when the previous member decl access specifier /// is different from the new member decl access specifier). -bool Sema::SetMemberAccessSpecifier(NamedDecl *MemberDecl, +bool SemaAccess::SetMemberAccessSpecifier(NamedDecl *MemberDecl, NamedDecl *PrevMemberDecl, AccessSpecifier LexicalAS) { if (!PrevMemberDecl) { @@ -1459,11 +1460,11 @@ static AccessResult CheckEffectiveAccess(Sema &S, llvm_unreachable("invalid access result"); } -static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc, +static SemaAccess::AccessResult CheckAccess(Sema &S, SourceLocation Loc, AccessTarget &Entity) { // If the access path is public, it's accessible everywhere. if (Entity.getAccess() == AS_public) - return Sema::AR_accessible; + return SemaAccess::AR_accessible; // If we're currently parsing a declaration, we may need to delay // access control checking, because our effective context might be @@ -1497,20 +1498,20 @@ static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc, } if (!IsFriendDeclaration) { S.DelayedDiagnostics.add(DelayedDiagnostic::makeAccess(Loc, Entity)); - return Sema::AR_delayed; + return SemaAccess::AR_delayed; } } EffectiveContext EC(S.CurContext); switch (CheckEffectiveAccess(S, EC, Loc, Entity)) { - case AR_accessible: return Sema::AR_accessible; - case AR_inaccessible: return Sema::AR_inaccessible; - case AR_dependent: return Sema::AR_dependent; + case AR_accessible: return SemaAccess::AR_accessible; + case AR_inaccessible: return SemaAccess::AR_inaccessible; + case AR_dependent: return SemaAccess::AR_dependent; } llvm_unreachable("invalid access result"); } -void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) { +void SemaAccess::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) { // Access control for names used in the declarations of functions // and function templates should normally be evaluated in the context // of the declaration, just in case it's a friend of something. @@ -1532,19 +1533,19 @@ void Sema::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) { AccessTarget Target(DD.getAccessData()); - if (CheckEffectiveAccess(*this, EC, DD.Loc, Target) == ::AR_inaccessible) + if (CheckEffectiveAccess(SemaRef, EC, DD.Loc, Target) == ::AR_inaccessible) DD.Triggered = true; } -void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD, +void SemaAccess::HandleDependentAccessCheck(const DependentDiagnostic &DD, const MultiLevelTemplateArgumentList &TemplateArgs) { SourceLocation Loc = DD.getAccessLoc(); AccessSpecifier Access = DD.getAccess(); - Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(), + Decl *NamingD = SemaRef.FindInstantiatedDecl(Loc, DD.getAccessNamingClass(), TemplateArgs); if (!NamingD) return; - Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(), + Decl *TargetD = SemaRef.FindInstantiatedDecl(Loc, DD.getAccessTarget(), TemplateArgs); if (!TargetD) return; @@ -1553,46 +1554,46 @@ void Sema::HandleDependentAccessCheck(const DependentDiagnostic &DD, NamedDecl *TargetDecl = cast(TargetD); QualType BaseObjectType = DD.getAccessBaseObjectType(); if (!BaseObjectType.isNull()) { - BaseObjectType = SubstType(BaseObjectType, TemplateArgs, Loc, + BaseObjectType = SemaRef.SubstType(BaseObjectType, TemplateArgs, Loc, DeclarationName()); if (BaseObjectType.isNull()) return; } - AccessTarget Entity(Context, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, DeclAccessPair::make(TargetDecl, Access), BaseObjectType); Entity.setDiag(DD.getDiagnostic()); - CheckAccess(*this, Loc, Entity); + CheckAccess(SemaRef, Loc, Entity); } else { - AccessTarget Entity(Context, + AccessTarget Entity(SemaRef.Context, AccessTarget::Base, cast(TargetD), cast(NamingD), Access); Entity.setDiag(DD.getDiagnostic()); - CheckAccess(*this, Loc, Entity); + CheckAccess(SemaRef, Loc, Entity); } } -Sema::AccessResult Sema::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, +SemaAccess::AccessResult SemaAccess::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, DeclAccessPair Found) { if (!getLangOpts().AccessControl || !E->getNamingClass() || Found.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(), + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, E->getNamingClass(), Found, QualType()); Entity.setDiag(diag::err_access) << E->getSourceRange(); - return CheckAccess(*this, E->getNameLoc(), Entity); + return CheckAccess(SemaRef, E->getNameLoc(), Entity); } /// Perform access-control checking on a previously-unresolved member /// access which has now been resolved to a member. -Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, +SemaAccess::AccessResult SemaAccess::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, DeclAccessPair Found) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) @@ -1602,16 +1603,16 @@ Sema::AccessResult Sema::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, if (E->isArrow()) BaseType = BaseType->castAs()->getPointeeType(); - AccessTarget Entity(Context, AccessTarget::Member, E->getNamingClass(), + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, E->getNamingClass(), Found, BaseType); Entity.setDiag(diag::err_access) << E->getSourceRange(); - return CheckAccess(*this, E->getMemberLoc(), Entity); + return CheckAccess(SemaRef, E->getMemberLoc(), Entity); } /// Is the given member accessible for the purposes of deciding whether to /// define a special member function as deleted? -bool Sema::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, +bool SemaAccess::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, DeclAccessPair Found, QualType ObjectType, SourceLocation Loc, @@ -1620,13 +1621,13 @@ bool Sema::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, if (Found.getAccess() == AS_public || !getLangOpts().AccessControl) return true; - AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, Found, ObjectType); // Suppress diagnostics. Entity.setDiag(Diag); - switch (CheckAccess(*this, Loc, Entity)) { + switch (CheckAccess(SemaRef, Loc, Entity)) { case AR_accessible: return true; case AR_inaccessible: return false; case AR_dependent: llvm_unreachable("dependent for =delete computation"); @@ -1635,7 +1636,7 @@ bool Sema::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, llvm_unreachable("bad access result"); } -Sema::AccessResult Sema::CheckDestructorAccess(SourceLocation Loc, +SemaAccess::AccessResult SemaAccess::CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, const PartialDiagnostic &PDiag, QualType ObjectTy) { @@ -1648,18 +1649,18 @@ Sema::AccessResult Sema::CheckDestructorAccess(SourceLocation Loc, return AR_accessible; CXXRecordDecl *NamingClass = Dtor->getParent(); - if (ObjectTy.isNull()) ObjectTy = Context.getTypeDeclType(NamingClass); + if (ObjectTy.isNull()) ObjectTy = SemaRef.Context.getTypeDeclType(NamingClass); - AccessTarget Entity(Context, AccessTarget::Member, NamingClass, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, DeclAccessPair::make(Dtor, Access), ObjectTy); Entity.setDiag(PDiag); // TODO: avoid copy - return CheckAccess(*this, Loc, Entity); + return CheckAccess(SemaRef, Loc, Entity); } /// Checks access to a constructor. -Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, +SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, @@ -1667,36 +1668,36 @@ Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) return AR_accessible; - PartialDiagnostic PD(PDiag()); + PartialDiagnostic PD(SemaRef.PDiag()); switch (Entity.getKind()) { default: - PD = PDiag(IsCopyBindingRefToTemp + PD = SemaRef.PDiag(IsCopyBindingRefToTemp ? diag::ext_rvalue_to_reference_access_ctor : diag::err_access_ctor); break; case InitializedEntity::EK_Base: - PD = PDiag(diag::err_access_base_ctor); + PD = SemaRef.PDiag(diag::err_access_base_ctor); PD << Entity.isInheritedVirtualBase() << Entity.getBaseSpecifier()->getType() - << llvm::to_underlying(getSpecialMember(Constructor)); + << llvm::to_underlying(SemaRef.getSpecialMember(Constructor)); break; case InitializedEntity::EK_Member: case InitializedEntity::EK_ParenAggInitMember: { const FieldDecl *Field = cast(Entity.getDecl()); - PD = PDiag(diag::err_access_field_ctor); + PD = SemaRef.PDiag(diag::err_access_field_ctor); PD << Field->getType() - << llvm::to_underlying(getSpecialMember(Constructor)); + << llvm::to_underlying(SemaRef.getSpecialMember(Constructor)); break; } case InitializedEntity::EK_LambdaCapture: { StringRef VarName = Entity.getCapturedVarName(); - PD = PDiag(diag::err_access_lambda_capture); + PD = SemaRef.PDiag(diag::err_access_lambda_capture); PD << VarName << Entity.getType() - << llvm::to_underlying(getSpecialMember(Constructor)); + << llvm::to_underlying(SemaRef.getSpecialMember(Constructor)); break; } @@ -1706,7 +1707,7 @@ Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, } /// Checks access to a constructor. -Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, +SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLoc, CXXConstructorDecl *Constructor, DeclAccessPair Found, const InitializedEntity &Entity, @@ -1728,7 +1729,7 @@ Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, if ((Entity.getKind() == InitializedEntity::EK_Base || Entity.getKind() == InitializedEntity::EK_Delegating) && !Entity.getParent()) { - ObjectClass = cast(CurContext)->getParent(); + ObjectClass = cast(SemaRef.CurContext)->getParent(); } else if (auto *Shadow = dyn_cast(Found.getDecl())) { // If we're using an inheriting constructor to construct an object, @@ -1739,16 +1740,16 @@ Sema::AccessResult Sema::CheckConstructorAccess(SourceLocation UseLoc, } AccessTarget AccessEntity( - Context, AccessTarget::Member, NamingClass, + SemaRef.Context, AccessTarget::Member, NamingClass, DeclAccessPair::make(Constructor, Found.getAccess()), - Context.getTypeDeclType(ObjectClass)); + SemaRef.Context.getTypeDeclType(ObjectClass)); AccessEntity.setDiag(PD); - return CheckAccess(*this, UseLoc, AccessEntity); + return CheckAccess(SemaRef, UseLoc, AccessEntity); } /// Checks access to an overloaded operator new or delete. -Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc, +SemaAccess::AccessResult SemaAccess::CheckAllocationAccess(SourceLocation OpLoc, SourceRange PlacementRange, CXXRecordDecl *NamingClass, DeclAccessPair Found, @@ -1758,17 +1759,17 @@ Sema::AccessResult Sema::CheckAllocationAccess(SourceLocation OpLoc, Found.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, Found, QualType()); if (Diagnose) Entity.setDiag(diag::err_access) << PlacementRange; - return CheckAccess(*this, OpLoc, Entity); + return CheckAccess(SemaRef, OpLoc, Entity); } /// Checks access to a member. -Sema::AccessResult Sema::CheckMemberAccess(SourceLocation UseLoc, +SemaAccess::AccessResult SemaAccess::CheckMemberAccess(SourceLocation UseLoc, CXXRecordDecl *NamingClass, DeclAccessPair Found) { if (!getLangOpts().AccessControl || @@ -1776,29 +1777,29 @@ Sema::AccessResult Sema::CheckMemberAccess(SourceLocation UseLoc, Found.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(Context, AccessTarget::Member, NamingClass, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, Found, QualType()); - return CheckAccess(*this, UseLoc, Entity); + return CheckAccess(SemaRef, UseLoc, Entity); } /// Checks implicit access to a member in a structured binding. -Sema::AccessResult -Sema::CheckStructuredBindingMemberAccess(SourceLocation UseLoc, +SemaAccess::AccessResult +SemaAccess::CheckStructuredBindingMemberAccess(SourceLocation UseLoc, CXXRecordDecl *DecomposedClass, DeclAccessPair Field) { if (!getLangOpts().AccessControl || Field.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(Context, AccessTarget::Member, DecomposedClass, Field, - Context.getRecordType(DecomposedClass)); + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, DecomposedClass, Field, + SemaRef.Context.getRecordType(DecomposedClass)); Entity.setDiag(diag::err_decomp_decl_inaccessible_field); - return CheckAccess(*this, UseLoc, Entity); + return CheckAccess(SemaRef, UseLoc, Entity); } -Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, +SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, const SourceRange &Range, DeclAccessPair Found) { @@ -1808,16 +1809,16 @@ Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, const RecordType *RT = ObjectExpr->getType()->castAs(); CXXRecordDecl *NamingClass = cast(RT->getDecl()); - AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, Found, ObjectExpr->getType()); Entity.setDiag(diag::err_access) << ObjectExpr->getSourceRange() << Range; - return CheckAccess(*this, OpLoc, Entity); + return CheckAccess(SemaRef, OpLoc, Entity); } /// Checks access to an overloaded member operator, including /// conversion operators. -Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, +SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, Expr *ArgExpr, DeclAccessPair Found) { @@ -1826,7 +1827,7 @@ Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, Found); } -Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, +SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, ArrayRef ArgExprs, DeclAccessPair FoundDecl) { @@ -1840,7 +1841,7 @@ Sema::AccessResult Sema::CheckMemberOperatorAccess(SourceLocation OpLoc, } /// Checks access to the target of a friend declaration. -Sema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) { +SemaAccess::AccessResult SemaAccess::CheckFriendAccess(NamedDecl *target) { assert(isa(target->getAsFunction())); // Friendship lookup is a redeclaration lookup, so there's never an @@ -1852,7 +1853,7 @@ Sema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) { CXXMethodDecl *method = cast(target->getAsFunction()); - AccessTarget entity(Context, AccessTarget::Member, + AccessTarget entity(SemaRef.Context, AccessTarget::Member, cast(target->getDeclContext()), DeclAccessPair::make(target, access), /*no instance context*/ QualType()); @@ -1862,16 +1863,16 @@ Sema::AccessResult Sema::CheckFriendAccess(NamedDecl *target) { // We need to bypass delayed-diagnostics because we might be called // while the ParsingDeclarator is active. - EffectiveContext EC(CurContext); - switch (CheckEffectiveAccess(*this, EC, target->getLocation(), entity)) { - case ::AR_accessible: return Sema::AR_accessible; - case ::AR_inaccessible: return Sema::AR_inaccessible; - case ::AR_dependent: return Sema::AR_dependent; + EffectiveContext EC(SemaRef.CurContext); + switch (CheckEffectiveAccess(SemaRef, EC, target->getLocation(), entity)) { + case ::AR_accessible: return SemaAccess::AR_accessible; + case ::AR_inaccessible: return SemaAccess::AR_inaccessible; + case ::AR_dependent: return SemaAccess::AR_dependent; } llvm_unreachable("invalid access result"); } -Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, +SemaAccess::AccessResult SemaAccess::CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair Found) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_none || @@ -1881,12 +1882,12 @@ Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, OverloadExpr *Ovl = OverloadExpr::find(OvlExpr).Expression; CXXRecordDecl *NamingClass = Ovl->getNamingClass(); - AccessTarget Entity(Context, AccessTarget::Member, NamingClass, Found, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, Found, /*no instance context*/ QualType()); Entity.setDiag(diag::err_access) << Ovl->getSourceRange(); - return CheckAccess(*this, Ovl->getNameLoc(), Entity); + return CheckAccess(SemaRef, Ovl->getNameLoc(), Entity); } /// Checks access for a hierarchy conversion. @@ -1895,7 +1896,7 @@ Sema::AccessResult Sema::CheckAddressOfMemberAccess(Expr *OvlExpr, /// control is disabled; some things rely on this for semantics /// \param ForceUnprivileged true if this check should proceed as if the /// context had no special privileges -Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc, +SemaAccess::AccessResult SemaAccess::CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, QualType Derived, const CXXBasePath &Path, @@ -1912,36 +1913,36 @@ Sema::AccessResult Sema::CheckBaseClassAccess(SourceLocation AccessLoc, BaseD = cast(Base->castAs()->getDecl()); DerivedD = cast(Derived->castAs()->getDecl()); - AccessTarget Entity(Context, AccessTarget::Base, BaseD, DerivedD, + AccessTarget Entity(SemaRef.Context, AccessTarget::Base, BaseD, DerivedD, Path.Access); if (DiagID) Entity.setDiag(DiagID) << Derived << Base; if (ForceUnprivileged) { - switch (CheckEffectiveAccess(*this, EffectiveContext(), + switch (CheckEffectiveAccess(SemaRef, EffectiveContext(), AccessLoc, Entity)) { - case ::AR_accessible: return Sema::AR_accessible; - case ::AR_inaccessible: return Sema::AR_inaccessible; - case ::AR_dependent: return Sema::AR_dependent; + case ::AR_accessible: return SemaAccess::AR_accessible; + case ::AR_inaccessible: return SemaAccess::AR_inaccessible; + case ::AR_dependent: return SemaAccess::AR_dependent; } llvm_unreachable("unexpected result from CheckEffectiveAccess"); } - return CheckAccess(*this, AccessLoc, Entity); + return CheckAccess(SemaRef, AccessLoc, Entity); } /// Checks access to all the declarations in the given result set. -void Sema::CheckLookupAccess(const LookupResult &R) { +void SemaAccess::CheckLookupAccess(const LookupResult &R) { assert(getLangOpts().AccessControl && "performing access check without access control"); assert(R.getNamingClass() && "performing access check without naming class"); for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I) { if (I.getAccess() != AS_public) { - AccessTarget Entity(Context, AccessedEntity::Member, + AccessTarget Entity(SemaRef.Context, AccessedEntity::Member, R.getNamingClass(), I.getPair(), R.getBaseObjectType()); Entity.setDiag(diag::err_access); - CheckAccess(*this, R.getNameLoc(), Entity); + CheckAccess(SemaRef, R.getNameLoc(), Entity); } } } @@ -1963,7 +1964,7 @@ void Sema::CheckLookupAccess(const LookupResult &R) { /// - target (unqualified lookup). /// BaseType is null, NamingClass is the parent class of 'target'. /// \return true if the Target is accessible from the Class, false otherwise. -bool Sema::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, +bool SemaAccess::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, QualType BaseType) { // Perform the C++ accessibility checks first. if (Target->isCXXClassMember() && NamingClass) { @@ -1973,10 +1974,10 @@ bool Sema::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, // accessed, which is described by the access in DeclAccessPair. // `IsAccessible` will examine the actual access of Target (i.e. // Decl->getAccess()) when calculating the access. - AccessTarget Entity(Context, AccessedEntity::Member, NamingClass, + AccessTarget Entity(SemaRef.Context, AccessedEntity::Member, NamingClass, DeclAccessPair::make(Target, AS_none), BaseType); - EffectiveContext EC(CurContext); - return ::IsAccessible(*this, EC, Entity) != ::AR_inaccessible; + EffectiveContext EC(SemaRef.CurContext); + return ::IsAccessible(SemaRef, EC, Entity) != ::AR_inaccessible; } if (ObjCIvarDecl *Ivar = dyn_cast(Target)) { @@ -1988,9 +1989,9 @@ bool Sema::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, // If we are inside a class or category implementation, determine the // interface we're in. ObjCInterfaceDecl *ClassOfMethodDecl = nullptr; - if (ObjCMethodDecl *MD = getCurMethodDecl()) + if (ObjCMethodDecl *MD = SemaRef.getCurMethodDecl()) ClassOfMethodDecl = MD->getClassInterface(); - else if (FunctionDecl *FD = getCurFunctionDecl()) { + else if (FunctionDecl *FD = SemaRef.getCurFunctionDecl()) { if (ObjCImplDecl *Impl = dyn_cast(FD->getLexicalDeclContext())) { if (ObjCImplementationDecl *IMPD @@ -2019,3 +2020,12 @@ bool Sema::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, return true; } + +bool SemaAccess::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, + DeclAccessPair Found, + QualType ObjectType) { + return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType, + SourceLocation(), SemaRef.PDiag()); +} + +SemaAccess::SemaAccess(Sema &S) : SemaBase(S) {} diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp index 483ec7e36eaed..093e1e458bac0 100644 --- a/clang/lib/Sema/SemaCast.cpp +++ b/clang/lib/Sema/SemaCast.cpp @@ -23,6 +23,7 @@ #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/Initialization.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "llvm/ADT/SmallVector.h" @@ -1735,16 +1736,16 @@ TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, } if (!CStyle) { - switch (Self.CheckBaseClassAccess(OpRange.getBegin(), + switch (Self.Access().CheckBaseClassAccess(OpRange.getBegin(), SrcType, DestType, Paths.front(), diag::err_downcast_from_inaccessible_base)) { - case Sema::AR_accessible: - case Sema::AR_delayed: // be optimistic - case Sema::AR_dependent: // be optimistic + case SemaAccess::AR_accessible: + case SemaAccess::AR_delayed: // be optimistic + case SemaAccess::AR_dependent: // be optimistic break; - case Sema::AR_inaccessible: + case SemaAccess::AR_inaccessible: msg = 0; return TC_Failed; } @@ -1834,18 +1835,18 @@ TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, } if (!CStyle) { - switch (Self.CheckBaseClassAccess(OpRange.getBegin(), + switch (Self.Access().CheckBaseClassAccess(OpRange.getBegin(), DestClass, SrcClass, Paths.front(), diag::err_upcast_to_inaccessible_base)) { - case Sema::AR_accessible: - case Sema::AR_delayed: - case Sema::AR_dependent: + case SemaAccess::AR_accessible: + case SemaAccess::AR_delayed: + case SemaAccess::AR_dependent: // Optimistically assume that the delayed and dependent cases // will work out. break; - case Sema::AR_inaccessible: + case SemaAccess::AR_inaccessible: msg = 0; return TC_Failed; } diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp index ad3ca4cc94ca6..08e6aa2d685ab 100644 --- a/clang/lib/Sema/SemaCodeComplete.cpp +++ b/clang/lib/Sema/SemaCodeComplete.cpp @@ -41,6 +41,7 @@ #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/Sema.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCodeCompletion.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" @@ -1715,7 +1716,7 @@ class CodeCompletionDeclConsumer : public VisibleDeclConsumer { ResultBuilder &Results; DeclContext *InitialLookupCtx; // NamingClass and BaseType are used for access-checking. See - // Sema::IsSimplyAccessible for details. + // SemaAccess::IsSimplyAccessible for details. CXXRecordDecl *NamingClass; QualType BaseType; std::vector FixIts; @@ -1778,7 +1779,7 @@ class CodeCompletionDeclConsumer : public VisibleDeclConsumer { NamingClass = nullptr; BaseType = QualType(); } - return Results.getSema().IsSimplyAccessible(ND, NamingClass, BaseType); + return Results.getSema().Access().IsSimplyAccessible(ND, NamingClass, BaseType); } }; } // namespace diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index f2b9202255cd4..000871001ae1a 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -45,6 +45,7 @@ #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaInternal.h" @@ -18159,7 +18160,7 @@ Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, // Set the access specifier. if (!Invalid && SearchDC->isRecord()) - SetMemberAccessSpecifier(New, PrevDecl, AS); + Access().SetMemberAccessSpecifier(New, PrevDecl, AS); if (PrevDecl) CheckRedeclarationInModule(New, PrevDecl); diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index e816ea3647a7c..0b84b8e2722ef 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -39,6 +39,7 @@ #include "clang/Sema/ParsedAttr.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaInternal.h" @@ -10457,7 +10458,7 @@ void Sema::PopParsingDeclaration(ParsingDeclState state, Decl *decl) { // inaccessible one at a time. if (AnyAccessFailures && isa(decl)) continue; - HandleDelayedAccessCheck(diag, decl); + Access().HandleDelayedAccessCheck(diag, decl); if (diag.Triggered) AnyAccessFailures = true; break; diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 8225381985052..6a47f5a90c16b 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -42,6 +42,7 @@ #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" @@ -1417,7 +1418,7 @@ static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc, } // ... [accessible, implied by other rules] base class of E. - S.CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD), + S.Access().CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD), *BestPath, diag::err_decomp_decl_inaccessible_base); AS = BestPath->Access; @@ -1501,7 +1502,7 @@ static bool checkMemberDecomposition(Sema &S, ArrayRef Bindings, // We already checked that the base class is accessible. // FIXME: Add 'const' to AccessedEntity's classes so we can remove the // const_cast here. - S.CheckStructuredBindingMemberAccess( + S.Access().CheckStructuredBindingMemberAccess( Loc, const_cast(OrigRD), DeclAccessPair::make(FD, CXXRecordDecl::MergeAccess( BasePair.getAccess(), FD->getAccess()))); @@ -3167,12 +3168,12 @@ Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, if (!IgnoreAccess) { // Check that the base class can be accessed. switch ( - CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) { - case AR_inaccessible: + Access().CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) { + case SemaAccess::AR_inaccessible: return true; - case AR_accessible: - case AR_dependent: - case AR_delayed: + case SemaAccess::AR_accessible: + case SemaAccess::AR_dependent: + case SemaAccess::AR_delayed: break; } } @@ -5904,7 +5905,7 @@ Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, // Dtor might still be missing, e.g because it's invalid. if (!Dtor) continue; - CheckDestructorAccess(Field->getLocation(), Dtor, + Access().CheckDestructorAccess(Field->getLocation(), Dtor, PDiag(diag::err_access_dtor_field) << Field->getDeclName() << FieldType); @@ -5954,7 +5955,7 @@ Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, continue; // FIXME: caret should be on the start of the class name - CheckDestructorAccess(Base.getBeginLoc(), Dtor, + Access().CheckDestructorAccess(Base.getBeginLoc(), Dtor, PDiag(diag::err_access_dtor_base) << Base.getType() << Base.getSourceRange(), Context.getTypeDeclType(ClassDecl)); @@ -5991,12 +5992,12 @@ void Sema::MarkVirtualBaseDestructorsReferenced( // Dtor might still be missing, e.g because it's invalid. if (!Dtor) continue; - if (CheckDestructorAccess( + if (Access().CheckDestructorAccess( ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), Context.getTypeDeclType(ClassDecl)) == - AR_accessible) { + SemaAccess::AR_accessible) { CheckDerivedToBaseConversion( Context.getTypeDeclType(ClassDecl), VBase.getType(), diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(), @@ -8266,7 +8267,7 @@ class DefaultedComparisonAnalyzer QualType ObjectType = Subobj.Kind == Subobject::Member ? Args[0]->getType() : S.Context.getRecordType(RD); - if (!S.isMemberAccessibleForDeletion( + if (!S.Access().isMemberAccessibleForDeletion( ArgClass, Best->FoundDecl, ObjectType, Subobj.Loc, Diagnose == ExplainDeleted ? S.PDiag(diag::note_defaulted_comparison_inaccessible) @@ -9465,7 +9466,7 @@ bool SpecialMemberDeletionInfo::isAccessible(Subobject Subobj, objectTy = S.Context.getTypeDeclType(target->getParent()); } - return S.isMemberAccessibleForDeletion( + return S.Access().isMemberAccessibleForDeletion( target->getParent(), DeclAccessPair::make(target, access), objectTy); } @@ -16234,7 +16235,7 @@ void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) { // though. if (!VD->getType()->isArrayType()) { MarkFunctionReferenced(VD->getLocation(), Destructor); - CheckDestructorAccess(VD->getLocation(), Destructor, + Access().CheckDestructorAccess(VD->getLocation(), Destructor, PDiag(diag::err_access_dtor_var) << VD->getDeclName() << VD->getType()); DiagnoseUseOfDecl(Destructor, VD->getLocation()); @@ -18100,7 +18101,7 @@ NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, if (ND->isInvalidDecl()) { FrD->setInvalidDecl(); } else { - if (DC->isRecord()) CheckFriendAccess(ND); + if (DC->isRecord()) Access().CheckFriendAccess(ND); FunctionDecl *FD; if (FunctionTemplateDecl *FTD = dyn_cast(ND)) diff --git a/clang/lib/Sema/SemaDeclObjC.cpp b/clang/lib/Sema/SemaDeclObjC.cpp index 6d4379283f198..7659ca192b7be 100644 --- a/clang/lib/Sema/SemaDeclObjC.cpp +++ b/clang/lib/Sema/SemaDeclObjC.cpp @@ -26,6 +26,7 @@ #include "clang/Sema/Lookup.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "llvm/ADT/DenseMap.h" @@ -5542,7 +5543,7 @@ void SemaObjC::SetIvarInitializers(ObjCImplementationDecl *ObjCImplementation) { CXXRecordDecl *RD = cast(RecordTy->getDecl()); if (CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(RD)) { SemaRef.MarkFunctionReferenced(Field->getLocation(), Destructor); - SemaRef.CheckDestructorAccess( + SemaRef.Access().CheckDestructorAccess( Field->getLocation(), Destructor, SemaRef.PDiag(diag::err_access_dtor_ivar) << Context.getBaseElementType(Field->getType())); diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp index 41bf273d12f2f..5969a7010e9c0 100644 --- a/clang/lib/Sema/SemaExceptionSpec.cpp +++ b/clang/lib/Sema/SemaExceptionSpec.cpp @@ -19,6 +19,7 @@ #include "clang/AST/TypeLoc.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" +#include "clang/Sema/SemaAccess.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" #include @@ -752,16 +753,16 @@ bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) { return false; // Do this check from a context without privileges. - switch (CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, + switch (Access().CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, Paths.front(), /*Diagnostic*/ 0, /*ForceCheck*/ true, /*ForceUnprivileged*/ true)) { - case AR_accessible: return true; - case AR_inaccessible: return false; - case AR_dependent: + case SemaAccess::AR_accessible: return true; + case SemaAccess::AR_inaccessible: return false; + case SemaAccess::AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); - case AR_delayed: + case SemaAccess::AR_delayed: llvm_unreachable("access check delayed in non-declaration"); } llvm_unreachable("unexpected access check result"); diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index e4601f7d6c47d..51f62d49b19e7 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -38,6 +38,7 @@ #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaLambda.h" @@ -1044,7 +1045,7 @@ bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, if (!RD->hasIrrelevantDestructor()) { if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) { MarkFunctionReferenced(E->getExprLoc(), Destructor); - CheckDestructorAccess(E->getExprLoc(), Destructor, + Access().CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_exception) << Ty); if (DiagnoseUseOfDecl(Destructor, E->getExprLoc())) return true; @@ -2615,8 +2616,8 @@ static bool resolveAllocationOverload( case OR_Success: { // Got one! FunctionDecl *FnDecl = Best->Function; - if (S.CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(), - Best->FoundDecl) == Sema::AR_inaccessible) + if (S.Access().CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(), + Best->FoundDecl) == SemaAccess::AR_inaccessible) return true; Operator = FnDecl; @@ -3022,7 +3023,7 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, } } - CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), + Access().CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), Matches[0].first); } else if (!Matches.empty()) { // We found multiple suitable operators. Per [expr.new]p20, that means we @@ -3381,8 +3382,8 @@ bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, return true; } - if (CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(), - Matches[0].Found, Diagnose) == AR_inaccessible) + if (Access().CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(), + Matches[0].Found, Diagnose) == SemaAccess::AR_inaccessible) return true; return false; @@ -3867,7 +3868,7 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, bool IsVirtualDelete = false; if (PointeeRD) { if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) { - CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, + Access().CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, PDiag(diag::err_access_dtor) << PointeeElem); IsVirtualDelete = Dtor->isVirtual(); } @@ -4216,7 +4217,7 @@ static ExprResult BuildCXXCastArgument(Sema &S, ConstructorArgs)) return ExprError(); - S.CheckConstructorAccess(CastLoc, Constructor, FoundDecl, + S.Access().CheckConstructorAccess(CastLoc, Constructor, FoundDecl, InitializedEntity::InitializeTemporary(Ty)); if (S.DiagnoseUseOfDecl(Method, CastLoc)) return ExprError(); @@ -4235,7 +4236,7 @@ static ExprResult BuildCXXCastArgument(Sema &S, case CK_UserDefinedConversion: { assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); - S.CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl); + S.Access().CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl); if (S.DiagnoseUseOfDecl(Method, CastLoc)) return ExprError(); @@ -7646,7 +7647,7 @@ ExprResult Sema::MaybeBindToTemporary(Expr *E) { if (Destructor) { MarkFunctionReferenced(E->getExprLoc(), Destructor); - CheckDestructorAccess(E->getExprLoc(), Destructor, + Access().CheckDestructorAccess(E->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << E->getType()); if (DiagnoseUseOfDecl(Destructor, E->getExprLoc())) @@ -7817,7 +7818,7 @@ ExprResult Sema::ActOnDecltypeExpression(Expr *E) { Temp->setDestructor(Destructor); MarkFunctionReferenced(Bind->getExprLoc(), Destructor); - CheckDestructorAccess(Bind->getExprLoc(), Destructor, + Access().CheckDestructorAccess(Bind->getExprLoc(), Destructor, PDiag(diag::err_access_dtor_temp) << Bind->getType()); if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc())) diff --git a/clang/lib/Sema/SemaExprMember.cpp b/clang/lib/Sema/SemaExprMember.cpp index 9aa60204bf29d..c6c2d77be008a 100644 --- a/clang/lib/Sema/SemaExprMember.cpp +++ b/clang/lib/Sema/SemaExprMember.cpp @@ -20,6 +20,7 @@ #include "clang/Sema/Overload.h" #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "clang/Sema/SemaOpenMP.h" diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index 353e911c5cc33..2e328fdca61c7 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -27,6 +27,7 @@ #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/Ownership.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" #include "llvm/ADT/APInt.h" @@ -1931,7 +1932,7 @@ static bool checkDestructorReference(QualType ElementType, SourceLocation Loc, return false; CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(CXXRD); - SemaRef.CheckDestructorAccess(Loc, Destructor, + SemaRef.Access().CheckDestructorAccess(Loc, Destructor, SemaRef.PDiag(diag::err_access_dtor_temp) << ElementType); SemaRef.MarkFunctionReferenced(Loc, Destructor); @@ -6858,7 +6859,7 @@ static ExprResult CopyObject(Sema &S, SmallVector ConstructorArgs; CurInit.get(); // Ownership transferred into MultiExprArg, below. - S.CheckConstructorAccess(Loc, Constructor, Best->FoundDecl, Entity, + S.Access().CheckConstructorAccess(Loc, Constructor, Best->FoundDecl, Entity, IsExtraneousCopy); if (IsExtraneousCopy) { @@ -6969,7 +6970,7 @@ static void CheckCXX98CompatAccessibleCopy(Sema &S, switch (OR) { case OR_Success: - S.CheckConstructorAccess(Loc, cast(Best->Function), + S.Access().CheckConstructorAccess(Loc, cast(Best->Function), Best->FoundDecl, Entity, Diag); // FIXME: Check default arguments as far as that's possible. break; @@ -7172,7 +7173,7 @@ PerformConstructorInitialization(Sema &S, return ExprError(); // Only check access if all of that succeeded. - S.CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, Entity); + S.Access().CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, Entity); if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc)) return ExprError(); @@ -8823,7 +8824,7 @@ ExprResult InitializationSequence::Perform(Sema &S, case SK_ResolveAddressOfOverloadedFunction: // Overload resolution determined which function invoke; update the // initializer to reflect that choice. - S.CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl); + S.Access().CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl); if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation())) return ExprError(); CurInit = S.FixOverloadedFunctionReference(CurInit, @@ -8968,7 +8969,7 @@ ExprResult InitializationSequence::Perform(Sema &S, if (CurInit.isInvalid()) return ExprError(); - S.CheckConstructorAccess(Kind.getLocation(), Constructor, FoundFn, + S.Access().CheckConstructorAccess(Kind.getLocation(), Constructor, FoundFn, Entity); if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation())) return ExprError(); @@ -8978,7 +8979,7 @@ ExprResult InitializationSequence::Perform(Sema &S, } else { // Build a call to the conversion function. CXXConversionDecl *Conversion = cast(Fn); - S.CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr, + S.Access().CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr, FoundFn); if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation())) return ExprError(); @@ -9012,7 +9013,7 @@ ExprResult InitializationSequence::Perform(Sema &S, if (const RecordType *Record = T->getAs()) { CXXDestructorDecl *Destructor = S.LookupDestructor(cast(Record->getDecl())); - S.CheckDestructorAccess(CurInit.get()->getBeginLoc(), Destructor, + S.Access().CheckDestructorAccess(CurInit.get()->getBeginLoc(), Destructor, S.PDiag(diag::err_access_dtor_temp) << T); S.MarkFunctionReferenced(CurInit.get()->getBeginLoc(), Destructor); if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getBeginLoc())) diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index 0834db95d42ad..c3c22e95e3b7f 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -33,6 +33,7 @@ #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/Sema.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/TemplateDeduction.h" #include "clang/Sema/TypoCorrection.h" @@ -4884,10 +4885,10 @@ void TypoCorrectionConsumer::performQualifiedLookups() { } for (LookupResult::iterator TRD = Result.begin(), TRDEnd = Result.end(); TRD != TRDEnd; ++TRD) { - if (SemaRef.CheckMemberAccess(TC.getCorrectionRange().getBegin(), + if (SemaRef.Access().CheckMemberAccess(TC.getCorrectionRange().getBegin(), NSType ? NSType->getAsCXXRecordDecl() : nullptr, - TRD.getPair()) == Sema::AR_accessible) + TRD.getPair()) == SemaAccess::AR_accessible) TC.addCorrectionDecl(*TRD); } if (TC.isResolved()) { diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index 6110e5229b076..4a2e68dd54876 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -35,6 +35,7 @@ #include "clang/Sema/Scope.h" #include "clang/Sema/ScopeInfo.h" #include "clang/Sema/Sema.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaInternal.h" #include "llvm/ADT/IndexedMap.h" #include "llvm/ADT/PointerEmbeddedInt.h" @@ -19510,9 +19511,9 @@ buildDeclareReductionRef(Sema &SemaRef, SourceLocation Loc, SourceRange Range, if (SemaRef.IsDerivedFrom(Loc, Ty, VD->getType(), Paths)) { if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType( VD->getType().getUnqualifiedType()))) { - if (SemaRef.CheckBaseClassAccess( + if (SemaRef.Access().CheckBaseClassAccess( Loc, VD->getType(), Ty, Paths.front(), - /*DiagID=*/0) != Sema::AR_inaccessible) { + /*DiagID=*/0) != SemaAccess::AR_inaccessible) { SemaRef.BuildBasePathArray(Paths, BasePath); return SemaRef.BuildDeclRefExpr( VD, VD->getType().getNonReferenceType(), VK_LValue, Loc); @@ -22357,9 +22358,9 @@ static ExprResult buildUserDefinedMapperRef(Sema &SemaRef, Scope *S, if (SemaRef.IsDerivedFrom(Loc, Type, VD->getType(), Paths)) { if (!Paths.isAmbiguous(SemaRef.Context.getCanonicalType( VD->getType().getUnqualifiedType()))) { - if (SemaRef.CheckBaseClassAccess( + if (SemaRef.Access().CheckBaseClassAccess( Loc, VD->getType(), Type, Paths.front(), - /*DiagID=*/0) != Sema::AR_inaccessible) { + /*DiagID=*/0) != SemaAccess::AR_inaccessible) { return SemaRef.BuildDeclRefExpr(VD, Type, VK_LValue, Loc); } } diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 2eb25237a0de6..6089654a04e2e 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -31,6 +31,7 @@ #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/Overload.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" @@ -3521,7 +3522,7 @@ bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, } if (!IgnoreBaseAccess) - CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass, + Access().CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass, Paths.front(), diag::err_downcast_from_inaccessible_base); @@ -6538,7 +6539,7 @@ diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, if (SemaRef.isSFINAEContext()) return true; - SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found); + SemaRef.Access().CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found); ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion, HadMultipleCandidates); if (Result.isInvalid()) @@ -6561,7 +6562,7 @@ static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, DeclAccessPair &Found) { CXXConversionDecl *Conversion = cast(Found->getUnderlyingDecl()); - SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found); + SemaRef.Access().CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found); QualType ToType = Conversion->getConversionType().getNonReferenceType(); if (!Converter.SuppressConversion) { @@ -13273,7 +13274,7 @@ Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr, if (Resolver.IsStaticMemberFunctionFromBoundPointer()) Resolver.ComplainIsStaticMemberFunctionFromBoundPointer(); else - CheckAddressOfMemberAccess(AddressOfExpr, FoundResult); + Access().CheckAddressOfMemberAccess(AddressOfExpr, FoundResult); } } @@ -13397,7 +13398,7 @@ bool Sema::resolveAndFixAddressOfSingleOverloadCandidate( // unavailable is consistent with our behavior elsewhere. So, always check // for both. DiagnoseUseOfDecl(Found, E->getExprLoc()); - CheckAddressOfMemberAccess(E, DAP); + Access().CheckAddressOfMemberAccess(E, DAP); ExprResult Res = FixOverloadedFunctionReference(E, DAP, Found); if (Res.isInvalid()) return false; @@ -14060,7 +14061,7 @@ static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, switch (OverloadResult) { case OR_Success: { FunctionDecl *FDecl = (*Best)->Function; - SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl); + SemaRef.Access().CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl); if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc())) return ExprError(); ExprResult Res = @@ -14390,7 +14391,7 @@ Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, // Convert the arguments. if (CXXMethodDecl *Method = dyn_cast(FnDecl)) { - CheckMemberOperatorAccess(OpLoc, Input, nullptr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(OpLoc, Input, nullptr, Best->FoundDecl); ExprResult InputInit; if (Method->isExplicitObjectMemberFunction()) @@ -14787,7 +14788,7 @@ ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, // Convert the arguments. if (CXXMethodDecl *Method = dyn_cast(FnDecl)) { // Best->Access is only meaningful for class members. - CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl); + Access().CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl); ExprResult Arg0, Arg1; unsigned ParamIdx = 0; @@ -15244,7 +15245,7 @@ ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, // We matched an overloaded operator. Build a call to that // operator. - CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl); // Convert the arguments. CXXMethodDecl *Method = cast(FnDecl); @@ -15546,7 +15547,7 @@ ExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, case OR_Success: Method = cast(Best->Function); FoundDecl = Best->FoundDecl; - CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl); + Access().CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl); if (DiagnoseUseOfOverloadedDecl(Best->FoundDecl, UnresExpr->getNameLoc())) break; // If FoundDecl is different from Method (such as if one is a template @@ -15871,7 +15872,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, = cast( Best->Conversions[0].UserDefined.ConversionFunction); - CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, + Access().CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl); if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc)) return ExprError(); @@ -15895,7 +15896,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc); } - CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl); // We found an overloaded operator(). Build a CXXOperatorCallExpr // that calls this method, using Object for the implicit object @@ -16068,7 +16069,7 @@ Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc, } } - CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl); // Convert the object parameter. CXXMethodDecl *Method = cast(Best->Function); diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 4937cce4621f0..237b0311d8d7c 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -33,6 +33,7 @@ #include "clang/Sema/Overload.h" #include "clang/Sema/ParsedTemplate.h" #include "clang/Sema/Scope.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/Template.h" @@ -2165,7 +2166,7 @@ DeclResult Sema::CheckClassTemplate( // Set the access specifier. if (!Invalid && TUK != TUK_Friend && NewTemplate->getDeclContext()->isRecord()) - SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS); + Access().SetMemberAccessSpecifier(NewTemplate, PrevClassTemplate, AS); // Set the lexical context of these templates NewClass->setLexicalDeclContext(CurContext); diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index 381d79b2fcd46..1dbb1511f1e7f 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -26,6 +26,7 @@ #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/ScopeInfo.h" +#include "clang/Sema/SemaAccess.h" #include "clang/Sema/SemaCUDA.h" #include "clang/Sema/SemaInternal.h" #include "clang/Sema/SemaObjC.h" @@ -1961,7 +1962,7 @@ TemplateDeclInstantiator::VisitFunctionTemplateDecl(FunctionTemplateDecl *D) { Owner->addDecl(InstTemplate); } else if (InstTemplate->getDeclContext()->isRecord() && !getPreviousDeclForInstantiation(D)) { - SemaRef.CheckFriendAccess(InstTemplate); + SemaRef.Access().CheckFriendAccess(InstTemplate); } return InstTemplate; @@ -2857,7 +2858,7 @@ Decl *TemplateDeclInstantiator::VisitCXXMethodDecl( // We only need to re-check access for methods which we didn't // manage to match during parsing. if (!D->getPreviousDecl()) - SemaRef.CheckFriendAccess(Method); + SemaRef.Access().CheckFriendAccess(Method); Record->makeDeclVisibleInContext(Method); @@ -6529,7 +6530,7 @@ void Sema::PerformDependentDiagnostics(const DeclContext *Pattern, for (auto *DD : Pattern->ddiags()) { switch (DD->getKind()) { case DependentDiagnostic::Access: - HandleDependentAccessCheck(*DD, TemplateArgs); + Access().HandleDependentAccessCheck(*DD, TemplateArgs); break; } } From 55757c3bf14e774e8d7ed0c2931daa4e97604e2a Mon Sep 17 00:00:00 2001 From: Vlad Serebrennikov Date: Sun, 19 May 2024 00:50:43 +0300 Subject: [PATCH 2/4] Run clang-format --- clang/include/clang/Sema/SemaAccess.h | 3 +- clang/lib/Sema/SemaAccess.cpp | 198 +++++++++++++------------- clang/lib/Sema/SemaCast.cpp | 18 ++- clang/lib/Sema/SemaCodeComplete.cpp | 3 +- clang/lib/Sema/SemaDeclCXX.cpp | 29 ++-- clang/lib/Sema/SemaExceptionSpec.cpp | 18 +-- clang/lib/Sema/SemaExprCXX.cpp | 36 +++-- clang/lib/Sema/SemaInit.cpp | 32 +++-- clang/lib/Sema/SemaLookup.cpp | 8 +- clang/lib/Sema/SemaOverload.cpp | 24 ++-- 10 files changed, 194 insertions(+), 175 deletions(-) diff --git a/clang/include/clang/Sema/SemaAccess.h b/clang/include/clang/Sema/SemaAccess.h index 280c41aa33124..dd89f042ccb89 100644 --- a/clang/include/clang/Sema/SemaAccess.h +++ b/clang/include/clang/Sema/SemaAccess.h @@ -100,8 +100,7 @@ class SemaAccess : public SemaBase { SourceLocation Loc, const PartialDiagnostic &Diag); bool isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, - DeclAccessPair Found, - QualType ObjectType); + DeclAccessPair Found, QualType ObjectType); void HandleDependentAccessCheck( const DependentDiagnostic &DD, diff --git a/clang/lib/Sema/SemaAccess.cpp b/clang/lib/Sema/SemaAccess.cpp index 1e9958d845ba7..9272020d83d33 100644 --- a/clang/lib/Sema/SemaAccess.cpp +++ b/clang/lib/Sema/SemaAccess.cpp @@ -39,8 +39,8 @@ enum AccessResult { /// Returns true on error (when the previous member decl access specifier /// is different from the new member decl access specifier). bool SemaAccess::SetMemberAccessSpecifier(NamedDecl *MemberDecl, - NamedDecl *PrevMemberDecl, - AccessSpecifier LexicalAS) { + NamedDecl *PrevMemberDecl, + AccessSpecifier LexicalAS) { if (!PrevMemberDecl) { // Use the lexical access specifier. MemberDecl->setAccess(LexicalAS); @@ -1461,7 +1461,7 @@ static AccessResult CheckEffectiveAccess(Sema &S, } static SemaAccess::AccessResult CheckAccess(Sema &S, SourceLocation Loc, - AccessTarget &Entity) { + AccessTarget &Entity) { // If the access path is public, it's accessible everywhere. if (Entity.getAccess() == AS_public) return SemaAccess::AR_accessible; @@ -1504,9 +1504,12 @@ static SemaAccess::AccessResult CheckAccess(Sema &S, SourceLocation Loc, EffectiveContext EC(S.CurContext); switch (CheckEffectiveAccess(S, EC, Loc, Entity)) { - case AR_accessible: return SemaAccess::AR_accessible; - case AR_inaccessible: return SemaAccess::AR_inaccessible; - case AR_dependent: return SemaAccess::AR_dependent; + case AR_accessible: + return SemaAccess::AR_accessible; + case AR_inaccessible: + return SemaAccess::AR_inaccessible; + case AR_dependent: + return SemaAccess::AR_dependent; } llvm_unreachable("invalid access result"); } @@ -1537,16 +1540,17 @@ void SemaAccess::HandleDelayedAccessCheck(DelayedDiagnostic &DD, Decl *D) { DD.Triggered = true; } -void SemaAccess::HandleDependentAccessCheck(const DependentDiagnostic &DD, - const MultiLevelTemplateArgumentList &TemplateArgs) { +void SemaAccess::HandleDependentAccessCheck( + const DependentDiagnostic &DD, + const MultiLevelTemplateArgumentList &TemplateArgs) { SourceLocation Loc = DD.getAccessLoc(); AccessSpecifier Access = DD.getAccess(); Decl *NamingD = SemaRef.FindInstantiatedDecl(Loc, DD.getAccessNamingClass(), - TemplateArgs); + TemplateArgs); if (!NamingD) return; - Decl *TargetD = SemaRef.FindInstantiatedDecl(Loc, DD.getAccessTarget(), - TemplateArgs); + Decl *TargetD = + SemaRef.FindInstantiatedDecl(Loc, DD.getAccessTarget(), TemplateArgs); if (!TargetD) return; if (DD.isAccessToMember()) { @@ -1555,37 +1559,34 @@ void SemaAccess::HandleDependentAccessCheck(const DependentDiagnostic &DD, QualType BaseObjectType = DD.getAccessBaseObjectType(); if (!BaseObjectType.isNull()) { BaseObjectType = SemaRef.SubstType(BaseObjectType, TemplateArgs, Loc, - DeclarationName()); + DeclarationName()); if (BaseObjectType.isNull()) return; } - AccessTarget Entity(SemaRef.Context, - AccessTarget::Member, - NamingClass, + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, DeclAccessPair::make(TargetDecl, Access), BaseObjectType); Entity.setDiag(DD.getDiagnostic()); CheckAccess(SemaRef, Loc, Entity); } else { - AccessTarget Entity(SemaRef.Context, - AccessTarget::Base, + AccessTarget Entity(SemaRef.Context, AccessTarget::Base, cast(TargetD), - cast(NamingD), - Access); + cast(NamingD), Access); Entity.setDiag(DD.getDiagnostic()); CheckAccess(SemaRef, Loc, Entity); } } -SemaAccess::AccessResult SemaAccess::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, - DeclAccessPair Found) { +SemaAccess::AccessResult +SemaAccess::CheckUnresolvedLookupAccess(UnresolvedLookupExpr *E, + DeclAccessPair Found) { if (!getLangOpts().AccessControl || !E->getNamingClass() || Found.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(SemaRef.Context, AccessTarget::Member, E->getNamingClass(), - Found, QualType()); + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, + E->getNamingClass(), Found, QualType()); Entity.setDiag(diag::err_access) << E->getSourceRange(); return CheckAccess(SemaRef, E->getNameLoc(), Entity); @@ -1593,8 +1594,9 @@ SemaAccess::AccessResult SemaAccess::CheckUnresolvedLookupAccess(UnresolvedLooku /// Perform access-control checking on a previously-unresolved member /// access which has now been resolved to a member. -SemaAccess::AccessResult SemaAccess::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, - DeclAccessPair Found) { +SemaAccess::AccessResult +SemaAccess::CheckUnresolvedMemberAccess(UnresolvedMemberExpr *E, + DeclAccessPair Found) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) return AR_accessible; @@ -1603,8 +1605,8 @@ SemaAccess::AccessResult SemaAccess::CheckUnresolvedMemberAccess(UnresolvedMembe if (E->isArrow()) BaseType = BaseType->castAs()->getPointeeType(); - AccessTarget Entity(SemaRef.Context, AccessTarget::Member, E->getNamingClass(), - Found, BaseType); + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, + E->getNamingClass(), Found, BaseType); Entity.setDiag(diag::err_access) << E->getSourceRange(); return CheckAccess(SemaRef, E->getMemberLoc(), Entity); @@ -1613,10 +1615,10 @@ SemaAccess::AccessResult SemaAccess::CheckUnresolvedMemberAccess(UnresolvedMembe /// Is the given member accessible for the purposes of deciding whether to /// define a special member function as deleted? bool SemaAccess::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, - DeclAccessPair Found, - QualType ObjectType, - SourceLocation Loc, - const PartialDiagnostic &Diag) { + DeclAccessPair Found, + QualType ObjectType, + SourceLocation Loc, + const PartialDiagnostic &Diag) { // Fast path. if (Found.getAccess() == AS_public || !getLangOpts().AccessControl) return true; @@ -1636,10 +1638,10 @@ bool SemaAccess::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, llvm_unreachable("bad access result"); } -SemaAccess::AccessResult SemaAccess::CheckDestructorAccess(SourceLocation Loc, - CXXDestructorDecl *Dtor, - const PartialDiagnostic &PDiag, - QualType ObjectTy) { +SemaAccess::AccessResult +SemaAccess::CheckDestructorAccess(SourceLocation Loc, CXXDestructorDecl *Dtor, + const PartialDiagnostic &PDiag, + QualType ObjectTy) { if (!getLangOpts().AccessControl) return AR_accessible; @@ -1649,22 +1651,21 @@ SemaAccess::AccessResult SemaAccess::CheckDestructorAccess(SourceLocation Loc, return AR_accessible; CXXRecordDecl *NamingClass = Dtor->getParent(); - if (ObjectTy.isNull()) ObjectTy = SemaRef.Context.getTypeDeclType(NamingClass); + if (ObjectTy.isNull()) + ObjectTy = SemaRef.Context.getTypeDeclType(NamingClass); AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, - DeclAccessPair::make(Dtor, Access), - ObjectTy); + DeclAccessPair::make(Dtor, Access), ObjectTy); Entity.setDiag(PDiag); // TODO: avoid copy return CheckAccess(SemaRef, Loc, Entity); } /// Checks access to a constructor. -SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLoc, - CXXConstructorDecl *Constructor, - DeclAccessPair Found, - const InitializedEntity &Entity, - bool IsCopyBindingRefToTemp) { +SemaAccess::AccessResult SemaAccess::CheckConstructorAccess( + SourceLocation UseLoc, CXXConstructorDecl *Constructor, + DeclAccessPair Found, const InitializedEntity &Entity, + bool IsCopyBindingRefToTemp) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) return AR_accessible; @@ -1672,8 +1673,8 @@ SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLo switch (Entity.getKind()) { default: PD = SemaRef.PDiag(IsCopyBindingRefToTemp - ? diag::ext_rvalue_to_reference_access_ctor - : diag::err_access_ctor); + ? diag::ext_rvalue_to_reference_access_ctor + : diag::err_access_ctor); break; @@ -1707,11 +1708,10 @@ SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLo } /// Checks access to a constructor. -SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLoc, - CXXConstructorDecl *Constructor, - DeclAccessPair Found, - const InitializedEntity &Entity, - const PartialDiagnostic &PD) { +SemaAccess::AccessResult SemaAccess::CheckConstructorAccess( + SourceLocation UseLoc, CXXConstructorDecl *Constructor, + DeclAccessPair Found, const InitializedEntity &Entity, + const PartialDiagnostic &PD) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) return AR_accessible; @@ -1749,11 +1749,9 @@ SemaAccess::AccessResult SemaAccess::CheckConstructorAccess(SourceLocation UseLo } /// Checks access to an overloaded operator new or delete. -SemaAccess::AccessResult SemaAccess::CheckAllocationAccess(SourceLocation OpLoc, - SourceRange PlacementRange, - CXXRecordDecl *NamingClass, - DeclAccessPair Found, - bool Diagnose) { +SemaAccess::AccessResult SemaAccess::CheckAllocationAccess( + SourceLocation OpLoc, SourceRange PlacementRange, + CXXRecordDecl *NamingClass, DeclAccessPair Found, bool Diagnose) { if (!getLangOpts().AccessControl || !NamingClass || Found.getAccess() == AS_public) @@ -1769,16 +1767,16 @@ SemaAccess::AccessResult SemaAccess::CheckAllocationAccess(SourceLocation OpLoc, } /// Checks access to a member. -SemaAccess::AccessResult SemaAccess::CheckMemberAccess(SourceLocation UseLoc, - CXXRecordDecl *NamingClass, - DeclAccessPair Found) { +SemaAccess::AccessResult +SemaAccess::CheckMemberAccess(SourceLocation UseLoc, CXXRecordDecl *NamingClass, + DeclAccessPair Found) { if (!getLangOpts().AccessControl || !NamingClass || Found.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, - Found, QualType()); + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, NamingClass, Found, + QualType()); return CheckAccess(SemaRef, UseLoc, Entity); } @@ -1786,23 +1784,23 @@ SemaAccess::AccessResult SemaAccess::CheckMemberAccess(SourceLocation UseLoc, /// Checks implicit access to a member in a structured binding. SemaAccess::AccessResult SemaAccess::CheckStructuredBindingMemberAccess(SourceLocation UseLoc, - CXXRecordDecl *DecomposedClass, - DeclAccessPair Field) { + CXXRecordDecl *DecomposedClass, + DeclAccessPair Field) { if (!getLangOpts().AccessControl || Field.getAccess() == AS_public) return AR_accessible; - AccessTarget Entity(SemaRef.Context, AccessTarget::Member, DecomposedClass, Field, - SemaRef.Context.getRecordType(DecomposedClass)); + AccessTarget Entity(SemaRef.Context, AccessTarget::Member, DecomposedClass, + Field, SemaRef.Context.getRecordType(DecomposedClass)); Entity.setDiag(diag::err_decomp_decl_inaccessible_field); return CheckAccess(SemaRef, UseLoc, Entity); } -SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, - Expr *ObjectExpr, - const SourceRange &Range, - DeclAccessPair Found) { +SemaAccess::AccessResult +SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, + const SourceRange &Range, + DeclAccessPair Found) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_public) return AR_accessible; @@ -1818,19 +1816,18 @@ SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation Op /// Checks access to an overloaded member operator, including /// conversion operators. -SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, - Expr *ObjectExpr, - Expr *ArgExpr, - DeclAccessPair Found) { +SemaAccess::AccessResult +SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, + Expr *ArgExpr, DeclAccessPair Found) { return CheckMemberOperatorAccess( OpLoc, ObjectExpr, ArgExpr ? ArgExpr->getSourceRange() : SourceRange(), Found); } -SemaAccess::AccessResult SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, - Expr *ObjectExpr, - ArrayRef ArgExprs, - DeclAccessPair FoundDecl) { +SemaAccess::AccessResult +SemaAccess::CheckMemberOperatorAccess(SourceLocation OpLoc, Expr *ObjectExpr, + ArrayRef ArgExprs, + DeclAccessPair FoundDecl) { SourceRange R; if (!ArgExprs.empty()) { R = SourceRange(ArgExprs.front()->getBeginLoc(), @@ -1865,15 +1862,18 @@ SemaAccess::AccessResult SemaAccess::CheckFriendAccess(NamedDecl *target) { // while the ParsingDeclarator is active. EffectiveContext EC(SemaRef.CurContext); switch (CheckEffectiveAccess(SemaRef, EC, target->getLocation(), entity)) { - case ::AR_accessible: return SemaAccess::AR_accessible; - case ::AR_inaccessible: return SemaAccess::AR_inaccessible; - case ::AR_dependent: return SemaAccess::AR_dependent; + case ::AR_accessible: + return SemaAccess::AR_accessible; + case ::AR_inaccessible: + return SemaAccess::AR_inaccessible; + case ::AR_dependent: + return SemaAccess::AR_dependent; } llvm_unreachable("invalid access result"); } -SemaAccess::AccessResult SemaAccess::CheckAddressOfMemberAccess(Expr *OvlExpr, - DeclAccessPair Found) { +SemaAccess::AccessResult +SemaAccess::CheckAddressOfMemberAccess(Expr *OvlExpr, DeclAccessPair Found) { if (!getLangOpts().AccessControl || Found.getAccess() == AS_none || Found.getAccess() == AS_public) @@ -1896,13 +1896,11 @@ SemaAccess::AccessResult SemaAccess::CheckAddressOfMemberAccess(Expr *OvlExpr, /// control is disabled; some things rely on this for semantics /// \param ForceUnprivileged true if this check should proceed as if the /// context had no special privileges -SemaAccess::AccessResult SemaAccess::CheckBaseClassAccess(SourceLocation AccessLoc, - QualType Base, - QualType Derived, - const CXXBasePath &Path, - unsigned DiagID, - bool ForceCheck, - bool ForceUnprivileged) { +SemaAccess::AccessResult +SemaAccess::CheckBaseClassAccess(SourceLocation AccessLoc, QualType Base, + QualType Derived, const CXXBasePath &Path, + unsigned DiagID, bool ForceCheck, + bool ForceUnprivileged) { if (!ForceCheck && !getLangOpts().AccessControl) return AR_accessible; @@ -1919,11 +1917,14 @@ SemaAccess::AccessResult SemaAccess::CheckBaseClassAccess(SourceLocation AccessL Entity.setDiag(DiagID) << Derived << Base; if (ForceUnprivileged) { - switch (CheckEffectiveAccess(SemaRef, EffectiveContext(), - AccessLoc, Entity)) { - case ::AR_accessible: return SemaAccess::AR_accessible; - case ::AR_inaccessible: return SemaAccess::AR_inaccessible; - case ::AR_dependent: return SemaAccess::AR_dependent; + switch ( + CheckEffectiveAccess(SemaRef, EffectiveContext(), AccessLoc, Entity)) { + case ::AR_accessible: + return SemaAccess::AR_accessible; + case ::AR_inaccessible: + return SemaAccess::AR_inaccessible; + case ::AR_dependent: + return SemaAccess::AR_dependent; } llvm_unreachable("unexpected result from CheckEffectiveAccess"); } @@ -1964,8 +1965,9 @@ void SemaAccess::CheckLookupAccess(const LookupResult &R) { /// - target (unqualified lookup). /// BaseType is null, NamingClass is the parent class of 'target'. /// \return true if the Target is accessible from the Class, false otherwise. -bool SemaAccess::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClass, - QualType BaseType) { +bool SemaAccess::IsSimplyAccessible(NamedDecl *Target, + CXXRecordDecl *NamingClass, + QualType BaseType) { // Perform the C++ accessibility checks first. if (Target->isCXXClassMember() && NamingClass) { if (!getLangOpts().CPlusPlus) @@ -2022,10 +2024,10 @@ bool SemaAccess::IsSimplyAccessible(NamedDecl *Target, CXXRecordDecl *NamingClas } bool SemaAccess::isMemberAccessibleForDeletion(CXXRecordDecl *NamingClass, - DeclAccessPair Found, - QualType ObjectType) { + DeclAccessPair Found, + QualType ObjectType) { return isMemberAccessibleForDeletion(NamingClass, Found, ObjectType, - SourceLocation(), SemaRef.PDiag()); + SourceLocation(), SemaRef.PDiag()); } SemaAccess::SemaAccess(Sema &S) : SemaBase(S) {} diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp index 093e1e458bac0..9aabfef7aabb5 100644 --- a/clang/lib/Sema/SemaCast.cpp +++ b/clang/lib/Sema/SemaCast.cpp @@ -1736,13 +1736,12 @@ TryStaticDowncast(Sema &Self, CanQualType SrcType, CanQualType DestType, } if (!CStyle) { - switch (Self.Access().CheckBaseClassAccess(OpRange.getBegin(), - SrcType, DestType, - Paths.front(), - diag::err_downcast_from_inaccessible_base)) { + switch (Self.Access().CheckBaseClassAccess( + OpRange.getBegin(), SrcType, DestType, Paths.front(), + diag::err_downcast_from_inaccessible_base)) { case SemaAccess::AR_accessible: - case SemaAccess::AR_delayed: // be optimistic - case SemaAccess::AR_dependent: // be optimistic + case SemaAccess::AR_delayed: // be optimistic + case SemaAccess::AR_dependent: // be optimistic break; case SemaAccess::AR_inaccessible: @@ -1835,10 +1834,9 @@ TryStaticMemberPointerUpcast(Sema &Self, ExprResult &SrcExpr, QualType SrcType, } if (!CStyle) { - switch (Self.Access().CheckBaseClassAccess(OpRange.getBegin(), - DestClass, SrcClass, - Paths.front(), - diag::err_upcast_to_inaccessible_base)) { + switch (Self.Access().CheckBaseClassAccess( + OpRange.getBegin(), DestClass, SrcClass, Paths.front(), + diag::err_upcast_to_inaccessible_base)) { case SemaAccess::AR_accessible: case SemaAccess::AR_delayed: case SemaAccess::AR_dependent: diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp index 08e6aa2d685ab..4f4a5c1b0ca5e 100644 --- a/clang/lib/Sema/SemaCodeComplete.cpp +++ b/clang/lib/Sema/SemaCodeComplete.cpp @@ -1779,7 +1779,8 @@ class CodeCompletionDeclConsumer : public VisibleDeclConsumer { NamingClass = nullptr; BaseType = QualType(); } - return Results.getSema().Access().IsSimplyAccessible(ND, NamingClass, BaseType); + return Results.getSema().Access().IsSimplyAccessible(ND, NamingClass, + BaseType); } }; } // namespace diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp index 6a47f5a90c16b..259f9ed6f6828 100644 --- a/clang/lib/Sema/SemaDeclCXX.cpp +++ b/clang/lib/Sema/SemaDeclCXX.cpp @@ -1419,7 +1419,8 @@ static DeclAccessPair findDecomposableBaseClass(Sema &S, SourceLocation Loc, // ... [accessible, implied by other rules] base class of E. S.Access().CheckBaseClassAccess(Loc, BaseType, S.Context.getRecordType(RD), - *BestPath, diag::err_decomp_decl_inaccessible_base); + *BestPath, + diag::err_decomp_decl_inaccessible_base); AS = BestPath->Access; ClassWithFields = BaseType->getAsCXXRecordDecl(); @@ -3167,8 +3168,8 @@ Sema::CheckDerivedToBaseConversion(QualType Derived, QualType Base, if (Path) { if (!IgnoreAccess) { // Check that the base class can be accessed. - switch ( - Access().CheckBaseClassAccess(Loc, Base, Derived, *Path, InaccessibleBaseID)) { + switch (Access().CheckBaseClassAccess(Loc, Base, Derived, *Path, + InaccessibleBaseID)) { case SemaAccess::AR_inaccessible: return true; case SemaAccess::AR_accessible: @@ -5906,9 +5907,8 @@ Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, if (!Dtor) continue; Access().CheckDestructorAccess(Field->getLocation(), Dtor, - PDiag(diag::err_access_dtor_field) - << Field->getDeclName() - << FieldType); + PDiag(diag::err_access_dtor_field) + << Field->getDeclName() << FieldType); MarkFunctionReferenced(Location, Dtor); DiagnoseUseOfDecl(Dtor, Location); @@ -5956,9 +5956,10 @@ Sema::MarkBaseAndMemberDestructorsReferenced(SourceLocation Location, // FIXME: caret should be on the start of the class name Access().CheckDestructorAccess(Base.getBeginLoc(), Dtor, - PDiag(diag::err_access_dtor_base) - << Base.getType() << Base.getSourceRange(), - Context.getTypeDeclType(ClassDecl)); + PDiag(diag::err_access_dtor_base) + << Base.getType() + << Base.getSourceRange(), + Context.getTypeDeclType(ClassDecl)); MarkFunctionReferenced(Location, Dtor); DiagnoseUseOfDecl(Dtor, Location); @@ -5996,8 +5997,7 @@ void Sema::MarkVirtualBaseDestructorsReferenced( ClassDecl->getLocation(), Dtor, PDiag(diag::err_access_dtor_vbase) << Context.getTypeDeclType(ClassDecl) << VBase.getType(), - Context.getTypeDeclType(ClassDecl)) == - SemaAccess::AR_accessible) { + Context.getTypeDeclType(ClassDecl)) == SemaAccess::AR_accessible) { CheckDerivedToBaseConversion( Context.getTypeDeclType(ClassDecl), VBase.getType(), diag::err_access_dtor_vbase, 0, ClassDecl->getLocation(), @@ -16236,8 +16236,8 @@ void Sema::FinalizeVarWithDestructor(VarDecl *VD, const RecordType *Record) { if (!VD->getType()->isArrayType()) { MarkFunctionReferenced(VD->getLocation(), Destructor); Access().CheckDestructorAccess(VD->getLocation(), Destructor, - PDiag(diag::err_access_dtor_var) - << VD->getDeclName() << VD->getType()); + PDiag(diag::err_access_dtor_var) + << VD->getDeclName() << VD->getType()); DiagnoseUseOfDecl(Destructor, VD->getLocation()); } @@ -18101,7 +18101,8 @@ NamedDecl *Sema::ActOnFriendFunctionDecl(Scope *S, Declarator &D, if (ND->isInvalidDecl()) { FrD->setInvalidDecl(); } else { - if (DC->isRecord()) Access().CheckFriendAccess(ND); + if (DC->isRecord()) + Access().CheckFriendAccess(ND); FunctionDecl *FD; if (FunctionTemplateDecl *FTD = dyn_cast(ND)) diff --git a/clang/lib/Sema/SemaExceptionSpec.cpp b/clang/lib/Sema/SemaExceptionSpec.cpp index 5969a7010e9c0..e78c38bd71bf2 100644 --- a/clang/lib/Sema/SemaExceptionSpec.cpp +++ b/clang/lib/Sema/SemaExceptionSpec.cpp @@ -10,7 +10,6 @@ // //===----------------------------------------------------------------------===// -#include "clang/Sema/SemaInternal.h" #include "clang/AST/ASTMutationListener.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/Expr.h" @@ -20,6 +19,7 @@ #include "clang/Basic/Diagnostic.h" #include "clang/Basic/SourceManager.h" #include "clang/Sema/SemaAccess.h" +#include "clang/Sema/SemaInternal.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallString.h" #include @@ -753,13 +753,15 @@ bool Sema::handlerCanCatch(QualType HandlerType, QualType ExceptionType) { return false; // Do this check from a context without privileges. - switch (Access().CheckBaseClassAccess(SourceLocation(), HandlerType, ExceptionType, - Paths.front(), - /*Diagnostic*/ 0, - /*ForceCheck*/ true, - /*ForceUnprivileged*/ true)) { - case SemaAccess::AR_accessible: return true; - case SemaAccess::AR_inaccessible: return false; + switch (Access().CheckBaseClassAccess(SourceLocation(), HandlerType, + ExceptionType, Paths.front(), + /*Diagnostic*/ 0, + /*ForceCheck*/ true, + /*ForceUnprivileged*/ true)) { + case SemaAccess::AR_accessible: + return true; + case SemaAccess::AR_inaccessible: + return false; case SemaAccess::AR_dependent: llvm_unreachable("access check dependent for unprivileged context"); case SemaAccess::AR_delayed: diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index 51f62d49b19e7..3ecf777519391 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -1046,7 +1046,8 @@ bool Sema::CheckCXXThrowOperand(SourceLocation ThrowLoc, if (CXXDestructorDecl *Destructor = LookupDestructor(RD)) { MarkFunctionReferenced(E->getExprLoc(), Destructor); Access().CheckDestructorAccess(E->getExprLoc(), Destructor, - PDiag(diag::err_access_dtor_exception) << Ty); + PDiag(diag::err_access_dtor_exception) + << Ty); if (DiagnoseUseOfDecl(Destructor, E->getExprLoc())) return true; } @@ -2616,8 +2617,9 @@ static bool resolveAllocationOverload( case OR_Success: { // Got one! FunctionDecl *FnDecl = Best->Function; - if (S.Access().CheckAllocationAccess(R.getNameLoc(), Range, R.getNamingClass(), - Best->FoundDecl) == SemaAccess::AR_inaccessible) + if (S.Access().CheckAllocationAccess(R.getNameLoc(), Range, + R.getNamingClass(), Best->FoundDecl) == + SemaAccess::AR_inaccessible) return true; Operator = FnDecl; @@ -3023,8 +3025,8 @@ bool Sema::FindAllocationFunctions(SourceLocation StartLoc, SourceRange Range, } } - Access().CheckAllocationAccess(StartLoc, Range, FoundDelete.getNamingClass(), - Matches[0].first); + Access().CheckAllocationAccess( + StartLoc, Range, FoundDelete.getNamingClass(), Matches[0].first); } else if (!Matches.empty()) { // We found multiple suitable operators. Per [expr.new]p20, that means we // call no 'operator delete' function, but we should at least warn the user. @@ -3382,8 +3384,9 @@ bool Sema::FindDeallocationFunction(SourceLocation StartLoc, CXXRecordDecl *RD, return true; } - if (Access().CheckAllocationAccess(StartLoc, SourceRange(), Found.getNamingClass(), - Matches[0].Found, Diagnose) == SemaAccess::AR_inaccessible) + if (Access().CheckAllocationAccess(StartLoc, SourceRange(), + Found.getNamingClass(), Matches[0].Found, + Diagnose) == SemaAccess::AR_inaccessible) return true; return false; @@ -3869,7 +3872,8 @@ Sema::ActOnCXXDelete(SourceLocation StartLoc, bool UseGlobal, if (PointeeRD) { if (CXXDestructorDecl *Dtor = LookupDestructor(PointeeRD)) { Access().CheckDestructorAccess(Ex.get()->getExprLoc(), Dtor, - PDiag(diag::err_access_dtor) << PointeeElem); + PDiag(diag::err_access_dtor) + << PointeeElem); IsVirtualDelete = Dtor->isVirtual(); } } @@ -4217,8 +4221,9 @@ static ExprResult BuildCXXCastArgument(Sema &S, ConstructorArgs)) return ExprError(); - S.Access().CheckConstructorAccess(CastLoc, Constructor, FoundDecl, - InitializedEntity::InitializeTemporary(Ty)); + S.Access().CheckConstructorAccess( + CastLoc, Constructor, FoundDecl, + InitializedEntity::InitializeTemporary(Ty)); if (S.DiagnoseUseOfDecl(Method, CastLoc)) return ExprError(); @@ -4236,7 +4241,8 @@ static ExprResult BuildCXXCastArgument(Sema &S, case CK_UserDefinedConversion: { assert(!From->getType()->isPointerType() && "Arg can't have pointer type!"); - S.Access().CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, FoundDecl); + S.Access().CheckMemberOperatorAccess(CastLoc, From, /*arg*/ nullptr, + FoundDecl); if (S.DiagnoseUseOfDecl(Method, CastLoc)) return ExprError(); @@ -7648,8 +7654,8 @@ ExprResult Sema::MaybeBindToTemporary(Expr *E) { if (Destructor) { MarkFunctionReferenced(E->getExprLoc(), Destructor); Access().CheckDestructorAccess(E->getExprLoc(), Destructor, - PDiag(diag::err_access_dtor_temp) - << E->getType()); + PDiag(diag::err_access_dtor_temp) + << E->getType()); if (DiagnoseUseOfDecl(Destructor, E->getExprLoc())) return ExprError(); @@ -7819,8 +7825,8 @@ ExprResult Sema::ActOnDecltypeExpression(Expr *E) { MarkFunctionReferenced(Bind->getExprLoc(), Destructor); Access().CheckDestructorAccess(Bind->getExprLoc(), Destructor, - PDiag(diag::err_access_dtor_temp) - << Bind->getType()); + PDiag(diag::err_access_dtor_temp) + << Bind->getType()); if (DiagnoseUseOfDecl(Destructor, Bind->getExprLoc())) return ExprError(); diff --git a/clang/lib/Sema/SemaInit.cpp b/clang/lib/Sema/SemaInit.cpp index 2e328fdca61c7..7eb3c13bd6285 100644 --- a/clang/lib/Sema/SemaInit.cpp +++ b/clang/lib/Sema/SemaInit.cpp @@ -1932,9 +1932,9 @@ static bool checkDestructorReference(QualType ElementType, SourceLocation Loc, return false; CXXDestructorDecl *Destructor = SemaRef.LookupDestructor(CXXRD); - SemaRef.Access().CheckDestructorAccess(Loc, Destructor, - SemaRef.PDiag(diag::err_access_dtor_temp) - << ElementType); + SemaRef.Access().CheckDestructorAccess( + Loc, Destructor, + SemaRef.PDiag(diag::err_access_dtor_temp) << ElementType); SemaRef.MarkFunctionReferenced(Loc, Destructor); return SemaRef.DiagnoseUseOfDecl(Destructor, Loc); } @@ -6860,7 +6860,7 @@ static ExprResult CopyObject(Sema &S, CurInit.get(); // Ownership transferred into MultiExprArg, below. S.Access().CheckConstructorAccess(Loc, Constructor, Best->FoundDecl, Entity, - IsExtraneousCopy); + IsExtraneousCopy); if (IsExtraneousCopy) { // If this is a totally extraneous copy for C++03 reference @@ -6970,8 +6970,9 @@ static void CheckCXX98CompatAccessibleCopy(Sema &S, switch (OR) { case OR_Success: - S.Access().CheckConstructorAccess(Loc, cast(Best->Function), - Best->FoundDecl, Entity, Diag); + S.Access().CheckConstructorAccess(Loc, + cast(Best->Function), + Best->FoundDecl, Entity, Diag); // FIXME: Check default arguments as far as that's possible. break; @@ -7173,7 +7174,8 @@ PerformConstructorInitialization(Sema &S, return ExprError(); // Only check access if all of that succeeded. - S.Access().CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, Entity); + S.Access().CheckConstructorAccess(Loc, Constructor, Step.Function.FoundDecl, + Entity); if (S.DiagnoseUseOfDecl(Step.Function.FoundDecl, Loc)) return ExprError(); @@ -8824,7 +8826,8 @@ ExprResult InitializationSequence::Perform(Sema &S, case SK_ResolveAddressOfOverloadedFunction: // Overload resolution determined which function invoke; update the // initializer to reflect that choice. - S.Access().CheckAddressOfMemberAccess(CurInit.get(), Step->Function.FoundDecl); + S.Access().CheckAddressOfMemberAccess(CurInit.get(), + Step->Function.FoundDecl); if (S.DiagnoseUseOfDecl(Step->Function.FoundDecl, Kind.getLocation())) return ExprError(); CurInit = S.FixOverloadedFunctionReference(CurInit, @@ -8969,8 +8972,8 @@ ExprResult InitializationSequence::Perform(Sema &S, if (CurInit.isInvalid()) return ExprError(); - S.Access().CheckConstructorAccess(Kind.getLocation(), Constructor, FoundFn, - Entity); + S.Access().CheckConstructorAccess(Kind.getLocation(), Constructor, + FoundFn, Entity); if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation())) return ExprError(); @@ -8979,8 +8982,8 @@ ExprResult InitializationSequence::Perform(Sema &S, } else { // Build a call to the conversion function. CXXConversionDecl *Conversion = cast(Fn); - S.Access().CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), nullptr, - FoundFn); + S.Access().CheckMemberOperatorAccess(Kind.getLocation(), CurInit.get(), + nullptr, FoundFn); if (S.DiagnoseUseOfDecl(FoundFn, Kind.getLocation())) return ExprError(); @@ -9013,8 +9016,9 @@ ExprResult InitializationSequence::Perform(Sema &S, if (const RecordType *Record = T->getAs()) { CXXDestructorDecl *Destructor = S.LookupDestructor(cast(Record->getDecl())); - S.Access().CheckDestructorAccess(CurInit.get()->getBeginLoc(), Destructor, - S.PDiag(diag::err_access_dtor_temp) << T); + S.Access().CheckDestructorAccess( + CurInit.get()->getBeginLoc(), Destructor, + S.PDiag(diag::err_access_dtor_temp) << T); S.MarkFunctionReferenced(CurInit.get()->getBeginLoc(), Destructor); if (S.DiagnoseUseOfDecl(Destructor, CurInit.get()->getBeginLoc())) return ExprError(); diff --git a/clang/lib/Sema/SemaLookup.cpp b/clang/lib/Sema/SemaLookup.cpp index c3c22e95e3b7f..6e888612b8e8b 100644 --- a/clang/lib/Sema/SemaLookup.cpp +++ b/clang/lib/Sema/SemaLookup.cpp @@ -4885,10 +4885,10 @@ void TypoCorrectionConsumer::performQualifiedLookups() { } for (LookupResult::iterator TRD = Result.begin(), TRDEnd = Result.end(); TRD != TRDEnd; ++TRD) { - if (SemaRef.Access().CheckMemberAccess(TC.getCorrectionRange().getBegin(), - NSType ? NSType->getAsCXXRecordDecl() - : nullptr, - TRD.getPair()) == SemaAccess::AR_accessible) + if (SemaRef.Access().CheckMemberAccess( + TC.getCorrectionRange().getBegin(), + NSType ? NSType->getAsCXXRecordDecl() : nullptr, + TRD.getPair()) == SemaAccess::AR_accessible) TC.addCorrectionDecl(*TRD); } if (TC.isResolved()) { diff --git a/clang/lib/Sema/SemaOverload.cpp b/clang/lib/Sema/SemaOverload.cpp index 6089654a04e2e..6c9c92383f009 100644 --- a/clang/lib/Sema/SemaOverload.cpp +++ b/clang/lib/Sema/SemaOverload.cpp @@ -3523,8 +3523,8 @@ bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, if (!IgnoreBaseAccess) Access().CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass, - Paths.front(), - diag::err_downcast_from_inaccessible_base); + Paths.front(), + diag::err_downcast_from_inaccessible_base); // Must be a base to derived member conversion. BuildBasePathArray(Paths, BasePath); @@ -6539,7 +6539,8 @@ diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, if (SemaRef.isSFINAEContext()) return true; - SemaRef.Access().CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found); + SemaRef.Access().CheckMemberOperatorAccess(From->getExprLoc(), From, + nullptr, Found); ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion, HadMultipleCandidates); if (Result.isInvalid()) @@ -6562,7 +6563,8 @@ static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From, DeclAccessPair &Found) { CXXConversionDecl *Conversion = cast(Found->getUnderlyingDecl()); - SemaRef.Access().CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found); + SemaRef.Access().CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, + Found); QualType ToType = Conversion->getConversionType().getNonReferenceType(); if (!Converter.SuppressConversion) { @@ -14391,7 +14393,8 @@ Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc, // Convert the arguments. if (CXXMethodDecl *Method = dyn_cast(FnDecl)) { - Access().CheckMemberOperatorAccess(OpLoc, Input, nullptr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(OpLoc, Input, nullptr, + Best->FoundDecl); ExprResult InputInit; if (Method->isExplicitObjectMemberFunction()) @@ -14788,7 +14791,8 @@ ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc, // Convert the arguments. if (CXXMethodDecl *Method = dyn_cast(FnDecl)) { // Best->Access is only meaningful for class members. - Access().CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl); + Access().CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], + Best->FoundDecl); ExprResult Arg0, Arg1; unsigned ParamIdx = 0; @@ -15245,7 +15249,8 @@ ExprResult Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, // We matched an overloaded operator. Build a call to that // operator. - Access().CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(LLoc, Args[0], ArgExpr, + Best->FoundDecl); // Convert the arguments. CXXMethodDecl *Method = cast(FnDecl); @@ -15873,7 +15878,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, Best->Conversions[0].UserDefined.ConversionFunction); Access().CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, - Best->FoundDecl); + Best->FoundDecl); if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc)) return ExprError(); assert(Conv == Best->FoundDecl.getDecl() && @@ -15896,7 +15901,8 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj, return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc); } - Access().CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl); + Access().CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, + Best->FoundDecl); // We found an overloaded operator(). Build a CXXOperatorCallExpr // that calls this method, using Object for the implicit object From cb11cc60400e57324fd40ee0065038c0b0587f95 Mon Sep 17 00:00:00 2001 From: Vlad Serebrennikov Date: Sun, 19 May 2024 00:52:27 +0300 Subject: [PATCH 3/4] Fix table of contents in `Sema` --- clang/include/clang/Sema/Sema.h | 63 ++++++++++++++++----------------- 1 file changed, 31 insertions(+), 32 deletions(-) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 0bbc20d1766e5..4b0cac3b15331 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -452,39 +452,38 @@ class Sema final : public SemaBase { // Table of Contents // ----------------- // 1. Semantic Analysis (Sema.cpp) - // 2. C++ Access Control (SemaAccess.cpp) - // 3. Attributes (SemaAttr.cpp) - // 4. Availability Attribute Handling (SemaAvailability.cpp) - // 5. Casts (SemaCast.cpp) - // 6. Extra Semantic Checking (SemaChecking.cpp) - // 7. C++ Coroutines (SemaCoroutine.cpp) - // 8. C++ Scope Specifiers (SemaCXXScopeSpec.cpp) - // 9. Declarations (SemaDecl.cpp) - // 10. Declaration Attribute Handling (SemaDeclAttr.cpp) - // 11. C++ Declarations (SemaDeclCXX.cpp) - // 12. C++ Exception Specifications (SemaExceptionSpec.cpp) - // 13. Expressions (SemaExpr.cpp) - // 14. C++ Expressions (SemaExprCXX.cpp) - // 15. Member Access Expressions (SemaExprMember.cpp) - // 16. Initializers (SemaInit.cpp) - // 17. C++ Lambda Expressions (SemaLambda.cpp) - // 18. Name Lookup (SemaLookup.cpp) - // 19. Modules (SemaModule.cpp) - // 20. C++ Overloading (SemaOverload.cpp) - // 21. Pseudo-Object (SemaPseudoObject.cpp) - // 22. Statements (SemaStmt.cpp) - // 23. `inline asm` Statement (SemaStmtAsm.cpp) - // 24. Statement Attribute Handling (SemaStmtAttr.cpp) - // 25. C++ Templates (SemaTemplate.cpp) - // 26. C++ Template Argument Deduction (SemaTemplateDeduction.cpp) - // 27. C++ Template Instantiation (SemaTemplateInstantiate.cpp) - // 28. C++ Template Declaration Instantiation + // 2. Attributes (SemaAttr.cpp) + // 3. Availability Attribute Handling (SemaAvailability.cpp) + // 4. Casts (SemaCast.cpp) + // 5. Extra Semantic Checking (SemaChecking.cpp) + // 6. C++ Coroutines (SemaCoroutine.cpp) + // 7. C++ Scope Specifiers (SemaCXXScopeSpec.cpp) + // 8. Declarations (SemaDecl.cpp) + // 9. Declaration Attribute Handling (SemaDeclAttr.cpp) + // 10. C++ Declarations (SemaDeclCXX.cpp) + // 11. C++ Exception Specifications (SemaExceptionSpec.cpp) + // 12. Expressions (SemaExpr.cpp) + // 13. C++ Expressions (SemaExprCXX.cpp) + // 14. Member Access Expressions (SemaExprMember.cpp) + // 15. Initializers (SemaInit.cpp) + // 16. C++ Lambda Expressions (SemaLambda.cpp) + // 17. Name Lookup (SemaLookup.cpp) + // 18. Modules (SemaModule.cpp) + // 19. C++ Overloading (SemaOverload.cpp) + // 20. Pseudo-Object (SemaPseudoObject.cpp) + // 21. Statements (SemaStmt.cpp) + // 22. `inline asm` Statement (SemaStmtAsm.cpp) + // 23. Statement Attribute Handling (SemaStmtAttr.cpp) + // 24. C++ Templates (SemaTemplate.cpp) + // 25. C++ Template Argument Deduction (SemaTemplateDeduction.cpp) + // 26. C++ Template Instantiation (SemaTemplateInstantiate.cpp) + // 27. C++ Template Declaration Instantiation // (SemaTemplateInstantiateDecl.cpp) - // 29. C++ Variadic Templates (SemaTemplateVariadic.cpp) - // 30. Constraints and Concepts (SemaConcept.cpp) - // 31. Types (SemaType.cpp) - // 32. FixIt Helpers (SemaFixItUtils.cpp) - // 33. Name Lookup for RISC-V Vector Intrinsic (SemaRISCVVectorLookup.cpp) + // 28. C++ Variadic Templates (SemaTemplateVariadic.cpp) + // 29. Constraints and Concepts (SemaConcept.cpp) + // 30. Types (SemaType.cpp) + // 31. FixIt Helpers (SemaFixItUtils.cpp) + // 32. Name Lookup for RISC-V Vector Intrinsic (SemaRISCVVectorLookup.cpp) /// \name Semantic Analysis /// Implementations are in Sema.cpp From 314c19664fd9d03c51c93f9d865a93ee0268576d Mon Sep 17 00:00:00 2001 From: Vlad Serebrennikov Date: Mon, 20 May 2024 17:59:17 +0300 Subject: [PATCH 4/4] Add missing newline at the end of `SemaAccess.h` --- clang/include/clang/Sema/SemaAccess.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/clang/include/clang/Sema/SemaAccess.h b/clang/include/clang/Sema/SemaAccess.h index dd89f042ccb89..b249c431c76d5 100644 --- a/clang/include/clang/Sema/SemaAccess.h +++ b/clang/include/clang/Sema/SemaAccess.h @@ -109,4 +109,4 @@ class SemaAccess : public SemaBase { }; } // namespace clang -#endif // LLVM_CLANG_SEMA_SEMAACCESS_H \ No newline at end of file +#endif // LLVM_CLANG_SEMA_SEMAACCESS_H