Sema: Request-ify WitnessChecker::getRequiredAccessScope()/isUsableFromInlineRequired()

Author: slavapestov

include/swift/AST/TypeCheckRequests.h

@@ -2806,6 +2806,28 @@ class ResolveImplicitMemberRequest
   bool isCached() const { return true; }
 };
 
+using ConformanceAccessScope =
+    std::pair<AccessScope, /*witnessesMustBeUsableFromInline=*/bool>;
+
+class ConformanceAccessScopeRequest
+    : public SimpleRequest<ConformanceAccessScopeRequest,
+                           ConformanceAccessScope(DeclContext *, ProtocolDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ConformanceAccessScope
+  evaluate(Evaluator &evaluator, DeclContext *dc, ProtocolDecl *proto) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 class TypeWitnessRequest
     : public SimpleRequest<TypeWitnessRequest,
                            TypeWitnessAndDecl(NormalProtocolConformance *,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -418,6 +418,9 @@ SWIFT_REQUEST(TypeChecker, SynthesizeDefaultInitRequest,
               ConstructorDecl *(NominalTypeDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, TypeCheckSourceFileRequest,
               bool(SouceFile *), SeparatelyCached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ConformanceAccessScopeRequest,
+              ConformanceAccessScope(DeclContext *, ProtocolDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, TypeWitnessRequest,
               TypeWitnessAndDecl(NormalProtocolConformance *,
                                  AssociatedTypeDecl *),

lib/Sema/AssociatedTypeInference.cpp

@@ -159,7 +159,9 @@ void ConformanceChecker::recordTypeWitness(AssociatedTypeDecl *assocType,
 
     // Inject the typealias into the nominal decl that conforms to the protocol.
     auto nominal = DC->getSelfNominalTypeDecl();
-    AccessScope requiredAccessScope = getRequiredAccessScope();
+    auto requiredAccessScope = evaluateOrDefault(
+        Context.evaluator, ConformanceAccessScopeRequest{DC, Proto},
+        std::make_pair(AccessScope::getPublic(), false));
 
     if (!getASTContext().isSwiftVersionAtLeast(5) &&
         !DC->getParentModule()->isResilient()) {
@@ -179,17 +181,17 @@ void ConformanceChecker::recordTypeWitness(AssociatedTypeDecl *assocType,
           underlyingTypeScope->intersectWith(nominalAccessScope);
       assert(widestPossibleScope.has_value() &&
              "we found the nominal and the type witness, didn't we?");
-      requiredAccessScope = widestPossibleScope.value();
+      requiredAccessScope.first = widestPossibleScope.value();
     }
 
     // An associated type witness can never be less than fileprivate, since
     // it must always be at least as visible as the enclosing type.
     AccessLevel requiredAccess =
-        std::max(requiredAccessScope.accessLevelForDiagnostics(),
+        std::max(requiredAccessScope.first.accessLevelForDiagnostics(),
                  AccessLevel::FilePrivate);
 
     aliasDecl->setAccess(requiredAccess);
-    if (isUsableFromInlineRequired()) {
+    if (requiredAccessScope.second) {
       auto *attr =
           new (getASTContext()) UsableFromInlineAttr(/*implicit=*/true);
       aliasDecl->getAttrs().add(attr);

lib/Sema/TypeCheckProtocol.cpp

@@ -1605,48 +1605,51 @@ bool WitnessChecker::findBestWitness(
   return isReallyBest;
 }
 
-AccessScope WitnessChecker::getRequiredAccessScope() {
-  if (RequiredAccessScopeAndUsableFromInline.has_value())
-    return RequiredAccessScopeAndUsableFromInline.value().first;
-
-  AccessScope result = Proto->getFormalAccessScope(DC);
-
+ConformanceAccessScope ConformanceAccessScopeRequest::evaluate(
+    Evaluator &evaluator, DeclContext *dc, ProtocolDecl *proto) const {
+  AccessScope result = proto->getFormalAccessScope(dc);
   bool witnessesMustBeUsableFromInline = false;
-  if (Adoptee) {
-    const NominalTypeDecl *adoptingNominal = DC->getSelfNominalTypeDecl();
 
+  auto *nominal = dc->getSelfNominalTypeDecl();
+
+  // We're either looking at a concrete conformance, or the default witness
+  // table for a resilient protocol.
+  if (!isa<ProtocolDecl>(nominal)) {
     // Compute the intersection of the conforming type's access scope
     // and the protocol's access scope.
     auto scopeIntersection =
-        result.intersectWith(adoptingNominal->getFormalAccessScope(DC));
+        result.intersectWith(nominal->getFormalAccessScope(dc));
     assert(scopeIntersection.has_value());
     result = scopeIntersection.value();
 
     if (!result.isPublic()) {
       witnessesMustBeUsableFromInline =
-          Proto->getFormalAccessScope(
-            DC, /*usableFromInlineAsPublic*/true).isPublic() &&
-          adoptingNominal->getFormalAccessScope(
-            DC, /*usableFromInlineAsPublic*/true).isPublic();
+          proto->getFormalAccessScope(
+            dc, /*usableFromInlineAsPublic*/true).isPublic() &&
+          nominal->getFormalAccessScope(
+            dc, /*usableFromInlineAsPublic*/true).isPublic();
     }
   } else {
     if (!result.isPublic()) {
       witnessesMustBeUsableFromInline =
-          Proto->getFormalAccessScope(
-            DC, /*usableFromInlineAsPublic*/true).isPublic();
+          proto->getFormalAccessScope(
+            dc, /*usableFromInlineAsPublic*/true).isPublic();
     }
   }
 
-  RequiredAccessScopeAndUsableFromInline =
-      std::make_pair(result, witnessesMustBeUsableFromInline);
-  return result;
+  return std::make_pair(result, witnessesMustBeUsableFromInline);
 }
 
 bool WitnessChecker::checkWitnessAccess(ValueDecl *requirement,
                                         ValueDecl *witness,
                                         bool *isSetter) {
   *isSetter = false;
-  AccessScope actualScopeToCheck = getRequiredAccessScope();
+
+  auto requiredAccessScope = evaluateOrDefault(
+      Context.evaluator, ConformanceAccessScopeRequest{DC, Proto},
+      std::make_pair(AccessScope::getPublic(), false));
+
+  auto actualScopeToCheck = requiredAccessScope.first;
 
   // Setting the 'forConformance' flag means that we admit witnesses in
   // protocol extensions that we can see, but are not necessarily as
@@ -1669,7 +1672,7 @@ bool WitnessChecker::checkWitnessAccess(ValueDecl *requirement,
       }
     }
 
-    if (actualScopeToCheck.hasEqualDeclContextWith(getRequiredAccessScope()))
+    if (actualScopeToCheck.hasEqualDeclContextWith(requiredAccessScope.first))
       return true;
   }
 
@@ -1703,15 +1706,20 @@ RequirementCheck WitnessChecker::checkWitness(ValueDecl *requirement,
   if (!match.OptionalAdjustments.empty())
     return CheckKind::OptionalityConflict;
 
+  auto requiredAccessScope = evaluateOrDefault(
+      Context.evaluator, ConformanceAccessScopeRequest{DC, Proto},
+      std::make_pair(AccessScope::getPublic(), false));
+
   bool isSetter = false;
   if (checkWitnessAccess(requirement, match.Witness, &isSetter)) {
     CheckKind kind = (isSetter
                       ? CheckKind::AccessOfSetter
                       : CheckKind::Access);
-    return RequirementCheck(kind, getRequiredAccessScope());
+
+    return RequirementCheck(kind, requiredAccessScope.first);
   }
 
-  if (isUsableFromInlineRequired()) {
+  if (requiredAccessScope.second) {
     bool witnessIsUsableFromInline = match.Witness->getFormalAccessScope(
         DC, /*usableFromInlineAsPublic*/true).isPublic();
     if (!witnessIsUsableFromInline)
@@ -4655,24 +4663,27 @@ void ConformanceChecker::ensureRequirementsAreSatisfied() {
     checkObjCTypeErasedGenerics(assocType, type, typeDecl);
 
     if (typeDecl && !typeDecl->isImplicit()) {
+      auto requiredAccessScope = evaluateOrDefault(
+          Context.evaluator, ConformanceAccessScopeRequest{DC, Proto},
+          std::make_pair(AccessScope::getPublic(), false));
+
       // Check access.
       bool isSetter = false;
       if (checkWitnessAccess(assocType, typeDecl, &isSetter)) {
         assert(!isSetter);
 
         // Note: you must not capture 'this' in the below closure.
-        const DeclContext *DC = this->DC;
-        auto requiredAccessScope = getRequiredAccessScope();
+        auto *DC = this->DC;
 
         getASTContext().addDelayedConformanceDiag(Conformance, false,
             [DC, requiredAccessScope, typeDecl](
               NormalProtocolConformance *conformance) {
           AccessLevel requiredAccess =
-              requiredAccessScope.requiredAccessForDiagnostics();
+              requiredAccessScope.first.requiredAccessForDiagnostics();
           auto proto = conformance->getProtocol();
           auto protoAccessScope = proto->getFormalAccessScope(DC);
           bool protoForcesAccess =
-              requiredAccessScope.hasEqualDeclContextWith(protoAccessScope);
+              requiredAccessScope.first.hasEqualDeclContextWith(protoAccessScope);
           auto diagKind = protoForcesAccess
                             ? diag::type_witness_not_accessible_proto
                             : diag::type_witness_not_accessible_type;
@@ -4683,7 +4694,7 @@ void ConformanceChecker::ensureRequirementsAreSatisfied() {
         });
       }
 
-      if (isUsableFromInlineRequired()) {
+      if (requiredAccessScope.second) {
         bool witnessIsUsableFromInline = typeDecl->getFormalAccessScope(
             DC, /*usableFromInlineAsPublic*/true).isPublic();
         if (!witnessIsUsableFromInline)

lib/Sema/TypeCheckProtocol.h

@@ -264,22 +264,9 @@ class WitnessChecker {
 
   RequirementEnvironmentCache ReqEnvironmentCache;
 
-  llvm::Optional<std::pair<AccessScope, bool>>
-      RequiredAccessScopeAndUsableFromInline;
-
   WitnessChecker(ASTContext &ctx, ProtocolDecl *proto, Type adoptee,
                  DeclContext *dc);
 
-  bool isMemberOperator(FuncDecl *decl, Type type);
-
-  AccessScope getRequiredAccessScope();
-
-  bool isUsableFromInlineRequired() {
-    assert(RequiredAccessScopeAndUsableFromInline.has_value() &&
-           "must check access first using getRequiredAccessScope");
-    return RequiredAccessScopeAndUsableFromInline.value().second;
-  }
-
   void lookupValueWitnessesViaImplementsAttr(ValueDecl *req,
                                              SmallVector<ValueDecl *, 4>
                                              &witnesses);