Sema: Expose a utility on ExportContext for checking unavailability.

Code that wants to determine whether a given declaration should be considered
unavailable should use this new utility, which will take the unavailability of
the context of use into consideration.

NFC.

Author: tshortli

lib/Sema/TypeCheckAvailability.cpp

@@ -366,6 +366,18 @@ static bool isInsideCompatibleUnavailableDeclaration(
           inheritsAvailabilityFromPlatform(platform, *referencedPlatform));
 }
 
+const AvailableAttr *
+ExportContext::shouldDiagnoseDeclAsUnavailable(const Decl *D) const {
+  auto attr = AvailableAttr::isUnavailable(D);
+  if (!attr)
+    return nullptr;
+
+  if (isInsideCompatibleUnavailableDeclaration(D, *this, attr))
+    return nullptr;
+
+  return attr;
+}
+
 static bool shouldAllowReferenceToUnavailableInSwiftDeclaration(
     const Decl *D, const ExportContext &where) {
   auto *DC = where.getDeclContext();
@@ -2901,17 +2913,10 @@ class UnavailabilityDiagnosticInfo {
 static std::optional<UnavailabilityDiagnosticInfo>
 getExplicitUnavailabilityDiagnosticInfo(const Decl *decl,
                                         const ExportContext &where) {
-  auto *attr = AvailableAttr::isUnavailable(decl);
+  auto *attr = where.shouldDiagnoseDeclAsUnavailable(decl);
   if (!attr)
     return std::nullopt;
 
-  // Calling unavailable code from within code with the same
-  // unavailability is OK -- the eventual caller can't call the
-  // enclosing code in the same situations it wouldn't be able to
-  // call this code.
-  if (isInsideCompatibleUnavailableDeclaration(decl, where, attr))
-    return std::nullopt;
-
   ASTContext &ctx = decl->getASTContext();
   StringRef platform = "";
   StringRef versionedPlatform = "";

lib/Sema/TypeCheckAvailability.h

@@ -187,6 +187,12 @@ class ExportContext {
   /// Get the ExportabilityReason for diagnostics. If this is 'None', there
   /// are no restrictions on referencing unexported declarations.
   std::optional<ExportabilityReason> getExportabilityReason() const;
+
+  /// If \p decl is unconditionally unavailable in this context, and the context
+  /// is not also unavailable in the same way, then this returns the specific
+  /// `@available` attribute that makes the decl unavailable. Otherwise, returns
+  /// nullptr.
+  const AvailableAttr *shouldDiagnoseDeclAsUnavailable(const Decl *decl) const;
 };
 
 /// Check if a declaration is exported as part of a module's external interface.