[clang] Introduce SemaAccess
#92674
Open
[clang] Introduce SemaAccess
#92674
Conversation
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Endilll
added
the
clang:frontend
llvmbot
added
clang
|
@llvm/pr-subscribers-clang Author: Vlad Serebrennikov (Endilll) ChangesThis patch moves As usual, formatting changes are split into a separate commit. Patch is 82.52 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/92674.diff 20 Files Affected:
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..4b0cac3b15331 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;
@@ -451,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
@@ -984,6 +984,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 +1054,7 @@ class Sema final : public SemaBase {
mutable IdentifierInfo *Ident_super;
+ std::unique_ptr<SemaAccess> AccessPtr;
std::unique_ptr<SemaCodeCompletion> CodeCompletionPtr;
std::unique_ptr<SemaCUDA> CUDAPtr;
std::unique_ptr<SemaHLSL> HLSLPtr;
@@ -1065,93 +1071,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<Expr *> 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..dd89f042ccb89
--- /dev/null
+++ b/clang/include/clang/Sema/SemaAccess.h
@@ -0,0 +1,112 @@
+//===----- 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<Expr *> 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<SemaAccess>(*this)),
CodeCompletionPtr(
std::make_unique<SemaCodeCompletion>(*this, CodeCompleter)),
CUDAPtr(std::make_unique<SemaCUDA>(*this)),
diff --git a/clang/lib/Sema/SemaAccess.cpp b/clang/lib/Sema/SemaAccess.cpp
index 979a64b065f3d..9272020d83d33 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,9 +38,9 @@ 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,
- NamedDecl *PrevMemberDecl,
- AccessSpecifier LexicalAS) {
+bool SemaAccess::SetMemberAccessSpecifier(NamedDecl *MemberDecl,
+ NamedDecl *PrevMemberDecl,
+ AccessSpecifier LexicalAS) {
if (!PrevMemberDecl) {
// Use the lexical access specifier.
MemberDecl->setAccess(LexicalAS);
@@ -1459,11 +1460,11 @@ static AccessResult CheckEffectiveAccess(Sema &S,
llvm_unreachable("invalid access result");
}
-static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc,
- AccessTarget &Entity) {
+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,23 @@ 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,20 +1536,21 @@ 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,
- const MultiLevelTemplateArgumentList &TemplateArgs) {
+void SemaAccess::HandleDependentAccessCheck(
+ const DependentDiagnostic &DD,
+ const MultiLevelTemplateArgumentList &TemplateArgs) {
SourceLocation Loc = DD.getAccessLoc();
AccessSpecifier Access = DD.getAccess();
- Decl *NamingD = FindInstantiatedDecl(Loc, DD.getAccessNamingClass(),
- TemplateArgs);
+ Decl *NamingD = SemaRef.FindInstantiatedDecl(Loc, DD.getAccessNamingClass(),
+ TemplateArgs);
if (!NamingD) return;
- Decl *TargetD = FindInstantiatedDecl(Loc, DD.getAccessTarget(),
- ...
[truncated]
|
erichkeane
reviewed
May 20, 2024
| @@ -1459,11 +1460,11 @@ static AccessResult CheckEffectiveAccess(Sema &S, | |||
| llvm_unreachable("invalid access result"); | |||
| } | |||
|
|
|||
| static Sema::AccessResult CheckAccess(Sema &S, SourceLocation Loc, | |||
| AccessTarget &Entity) { | |||
| static SemaAccess::AccessResult CheckAccess(Sema &S, SourceLocation Loc, | |||
There was a problem hiding this comment.
i find myself wondering if this should just take SemaAccess instead of sema, with all the below churn. It seems to make more sense, even if it has to do an extraction of Sema in the function.
There was a problem hiding this comment.
I remember bringing this up early on in discussions with @AaronBallman. I agree with you that static functions should take reference to their own part of Sema instead of reference to big Sema. I found it rather awkward that a static function takes Sema& only to get it's part of Sema out of it. Back then we decided that static functions will continue to take Sema&.
Now that we moved a lot of code out of Sema, I can say that applying this kind of transformation immediately would significantly increase amount of changes in already big PRs that are splitting Sema up. So I'll continue as is, but that's definitely a point to revisit.
There was a problem hiding this comment.
Yeah, eventually it would be nice to clean up static functions so they have more limited access, but likely as follow-up work once the Great Splitting has finished.
erichkeane
approved these changes
May 20, 2024
|
(I have the same reservation as for the SemaCoroutine patch) |
AaronBallman
approved these changes
May 21, 2024
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This patch moves
Semafunctions that handle access checking into the newSemaAccessclass. This continues previous efforts to split Sema up. Additional context can be found in #84184.As usual, formatting changes are split into a separate commit.