Sema: Wrap up some availability-related state in a new ExportContext type

The ExportContext describes the restrictions, if any, on what
declarations can be uttered in a specific place in the
program. Here, the place is either the signature of a
declaration, or the body of a function.

Author: slavapestov

lib/Sema/ResilienceDiagnostics.cpp

@@ -29,9 +29,10 @@ using namespace swift;
 
 bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
                                            const ValueDecl *D,
-                                           const DeclContext *DC,
-                                           FragileFunctionKind Kind) {
-  assert(Kind.kind != FragileFunctionKind::None);
+                                           ExportContext where) {
+  auto fragileKind = where.getFragileFunctionKind();
+  if (fragileKind.kind == FragileFunctionKind::None)
+    return false;
 
   // Do some important fast-path checks that apply to all cases.
 
@@ -40,33 +41,33 @@ bool TypeChecker::diagnoseInlinableDeclRef(SourceLoc loc,
     return false;
 
   // Check whether the declaration is accessible.
-  if (diagnoseInlinableDeclRefAccess(loc, D, DC, Kind))
+  if (diagnoseInlinableDeclRefAccess(loc, D, where))
     return true;
 
   // Check whether the declaration comes from a publically-imported module.
   // Skip this check for accessors because the associated property or subscript
   // will also be checked, and will provide a better error message.
   if (!isa<AccessorDecl>(D))
-    if (diagnoseDeclRefExportability(loc, D, DC,
-                                     None, Kind))
+    if (diagnoseDeclRefExportability(loc, D, where))
       return true;
 
   return false;
 }
 
 bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
                                                  const ValueDecl *D,
-                                                 const DeclContext *DC,
-                                                 FragileFunctionKind Kind) {
-  assert(Kind.kind != FragileFunctionKind::None);
+                                                 ExportContext where) {
+  auto *DC = where.getDeclContext();
+  auto fragileKind = where.getFragileFunctionKind();
+  assert(fragileKind.kind != FragileFunctionKind::None);
 
   // Local declarations are OK.
   if (D->getDeclContext()->isLocalContext())
     return false;
 
   // Public declarations or SPI used from SPI are OK.
   if (D->getFormalAccessScope(/*useDC=*/nullptr,
-                              Kind.allowUsableFromInline).isPublic() &&
+                              fragileKind.allowUsableFromInline).isPublic() &&
       !(D->isSPI() && !DC->getInnermostDeclarationDeclContext()->isSPI()))
     return false;
 
@@ -126,10 +127,10 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
            loc, diagID,
            D->getDescriptiveKind(), diagName,
            D->getFormalAccessScope().accessLevelForDiagnostics(),
-           static_cast<unsigned>(Kind.kind),
+           static_cast<unsigned>(fragileKind.kind),
            isAccessor);
 
-  if (Kind.allowUsableFromInline) {
+  if (fragileKind.allowUsableFromInline) {
     Context.Diags.diagnose(D, diag::resilience_decl_declared_here,
                            D->getDescriptiveKind(), diagName, isAccessor);
   } else {
@@ -143,15 +144,15 @@ bool TypeChecker::diagnoseInlinableDeclRefAccess(SourceLoc loc,
 bool
 TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
                                           const ValueDecl *D,
-                                          const DeclContext *DC,
-                                          Optional<ExportabilityReason> reason,
-                                          FragileFunctionKind fragileKind) {
-  if (fragileKind.kind == FragileFunctionKind::None && !reason.hasValue())
+                                          ExportContext where) {
+  if (!where.mustOnlyReferenceExportedDecls())
     return false;
 
   auto definingModule = D->getModuleContext();
 
   auto downgradeToWarning = DowngradeToWarning::No;
+
+  auto *DC = where.getDeclContext();
   auto originKind = getDisallowedOriginKind(
       D,
       *DC->getParentSourceFile(),
@@ -162,6 +163,9 @@ TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
 
   ASTContext &ctx = definingModule->getASTContext();
 
+  auto fragileKind = where.getFragileFunctionKind();
+  auto reason = where.getExportabilityReason();
+
   if (fragileKind.kind == FragileFunctionKind::None) {
     auto errorOrWarning = downgradeToWarning == DowngradeToWarning::Yes?
                               diag::decl_from_hidden_module_warn:
@@ -187,24 +191,25 @@ TypeChecker::diagnoseDeclRefExportability(SourceLoc loc,
 bool
 TypeChecker::diagnoseConformanceExportability(SourceLoc loc,
                                               const RootProtocolConformance *rootConf,
-                                              const SourceFile &userSF,
-                                              const DeclContext *userDC,
-                                              Optional<ExportabilityReason> reason,
-                                              FragileFunctionKind fragileKind) {
-  if (fragileKind.kind == FragileFunctionKind::None && !reason.hasValue())
+                                              ExportContext where) {
+  if (!where.mustOnlyReferenceExportedDecls())
     return false;
 
+  auto *DC = where.getDeclContext();
   auto originKind = getDisallowedOriginKind(
       rootConf->getDeclContext()->getAsDecl(),
-      userSF, userDC->getInnermostDeclarationDeclContext());
+      *DC->getParentSourceFile(),
+      DC->getInnermostDeclarationDeclContext());
   if (originKind == DisallowedOriginKind::None)
     return false;
 
+  ModuleDecl *M = rootConf->getDeclContext()->getParentModule();
+  ASTContext &ctx = M->getASTContext();
+
+  auto reason = where.getExportabilityReason();
   if (!reason.hasValue())
     reason = ExportabilityReason::General;
 
-  ModuleDecl *M = rootConf->getDeclContext()->getParentModule();
-  ASTContext &ctx = M->getASTContext();
   ctx.Diags.diagnose(loc, diag::conformance_from_implementation_only_module,
                      rootConf->getType(),
                      rootConf->getProtocol()->getName(),

lib/Sema/TypeCheckAccess.cpp

@@ -1483,63 +1483,11 @@ swift::getDisallowedOriginKind(const Decl *decl,
   return DisallowedOriginKind::None;
 };
 
-static bool isExported(const ValueDecl *VD) {
-  if (VD->getAttrs().hasAttribute<ImplementationOnlyAttr>())
-    return false;
-
-  // Is this part of the module's API or ABI?
-  AccessScope accessScope =
-      VD->getFormalAccessScope(nullptr,
-                               /*treatUsableFromInlineAsPublic*/true);
-  if (accessScope.isPublic())
-    return true;
-
-  // Is this a stored property in a non-resilient struct or class?
-  auto *property = dyn_cast<VarDecl>(VD);
-  if (!property || !property->hasStorage() || property->isStatic())
-    return false;
-  auto *parentNominal = dyn_cast<NominalTypeDecl>(property->getDeclContext());
-  if (!parentNominal || parentNominal->isResilient())
-    return false;
-
-  // Is that struct or class part of the module's API or ABI?
-  AccessScope parentAccessScope = parentNominal->getFormalAccessScope(
-      nullptr, /*treatUsableFromInlineAsPublic*/true);
-  if (parentAccessScope.isPublic())
-    return true;
-
-  return false;
-}
-
-static bool isExported(Decl *D) {
-  if (auto *VD = dyn_cast<ValueDecl>(D)) {
-    return isExported(VD);
-  }
-  if (auto *PBD = dyn_cast<PatternBindingDecl>(D)) {
-    for (unsigned i = 0, e = PBD->getNumPatternEntries(); i < e; ++i) {
-      if (auto *VD = PBD->getAnchoringVarDecl(i))
-        return isExported(VD);
-    }
-
-    return false;
-  }
-  if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
-    if (auto *NTD = ED->getExtendedNominal())
-      return isExported(NTD);
-
-    return false;
-  }
-
-  return true;
-}
-
 namespace {
 
 /// Diagnose declarations whose signatures refer to unavailable types.
 class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
-  DeclContext *DC;
-  FragileFunctionKind FragileKind;
-  bool Exported;
+  ExportContext Where;
 
   void checkType(Type type, const TypeRepr *typeRepr, const Decl *context,
                  ExportabilityReason reason=ExportabilityReason::General,
@@ -1548,10 +1496,6 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
     if (type && type->hasError())
       return;
 
-    Optional<ExportabilityReason> optReason;
-    if (Exported)
-      optReason = reason;
-
     DeclAvailabilityFlags flags = None;
 
     // We allow a type to conform to a protocol that is less available than
@@ -1568,8 +1512,8 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
     if (auto *varDecl = dyn_cast<VarDecl>(context))
       loc = varDecl->getNameLoc();
 
-    diagnoseTypeAvailability(typeRepr, type, loc, DC,
-                             optReason, FragileKind, flags);
+    diagnoseTypeAvailability(typeRepr, type, loc,
+                             Where.forReason(reason), flags);
   }
 
   void checkGenericParams(const GenericContext *ownerCtx,
@@ -1598,10 +1542,7 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
 
 public:
   explicit DeclAvailabilityChecker(Decl *D)
-    : DC(D->getInnermostDeclContext()) {
-    FragileKind = DC->getFragileFunctionKind();
-    Exported = isExported(D);
-  }
+    : Where(ExportContext::forDeclSignature(D)) {}
 
   // Force all kinds to be handled at a lower level.
   void visitDecl(Decl *D) = delete;
@@ -1798,7 +1739,7 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
                 /*allowUnavailableProtocol=*/true);
     });
 
-    bool wasExported = Exported;
+    auto wasWhere = Where;
 
     // 2) If the extension contains exported members, the as-written
     // extended type should be exportable.
@@ -1810,14 +1751,14 @@ class DeclAvailabilityChecker : public DeclVisitor<DeclAvailabilityChecker> {
       return isExported(valueMember);
     });
 
-    Exported = wasExported && hasExportedMembers;
+    Where = wasWhere.forExported(hasExportedMembers);
     checkType(ED->getExtendedType(),  ED->getExtendedTypeRepr(), ED,
               ExportabilityReason::ExtensionWithPublicMembers);
 
     // 3) If the extension contains exported members or defines conformances,
     // the 'where' clause must only name exported types.
-    Exported = wasExported && (hasExportedMembers ||
-                               !ED->getInherited().empty());
+    Where = wasWhere.forExported(hasExportedMembers ||
+                                 !ED->getInherited().empty());
     checkConstrainedExtensionRequirements(ED, hasExportedMembers);
   }