AST: Introduce swift::getAvailabilityConstraintsForDecl().

This new query is designed to become the canonical source of information
regarding whether a declaration is available to use in a given
`AvailabilityContext`. It should be adopted as the foundational building block
for all other queries that answer more specific questions about the
availability of a specific delcaration.

The implementation of this query has been copied from a variety of sources
which should eventually be deleted once the new query has been fully adopted.

NFC.

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -26,6 +26,8 @@
 namespace swift {
 
 class ASTContext;
+class AvailabilityContext;
+class Decl;
 
 /// Represents the reason a declaration could be considered unavailable in a
 /// certain context.
@@ -110,6 +112,37 @@ class AvailabilityConstraint {
   bool isActiveForRuntimeQueries(ASTContext &ctx) const;
 };
 
+/// Represents a set of availability constraints that restrict use of a
+/// declaration in a particular context.
+class DeclAvailabilityConstraints {
+  using Storage = llvm::SmallVector<AvailabilityConstraint, 4>;
+  Storage constraints;
+
+public:
+  DeclAvailabilityConstraints() {}
+
+  void addConstraint(const AvailabilityConstraint &constraint) {
+    constraints.emplace_back(constraint);
+  }
+
+  using const_iterator = Storage::const_iterator;
+  const_iterator begin() const { return constraints.begin(); }
+  const_iterator end() const { return constraints.end(); }
+};
+
+/// Returns the `AvailabilityConstraint` that describes how \p attr restricts
+/// use of \p decl in \p context or `std::nullopt` if there is no restriction.
+std::optional<AvailabilityConstraint>
+getAvailabilityConstraintForAttr(const Decl *decl,
+                                 const SemanticAvailableAttr &attr,
+                                 const AvailabilityContext &context);
+
+/// Returns the set of availability constraints that restrict use of \p decl
+/// when it is referenced from the given context. In other words, it is the
+/// collection of of `@available` attributes with unsatisfied conditions.
+DeclAvailabilityConstraints
+getAvailabilityConstraintsForDecl(const Decl *decl,
+                                  const AvailabilityContext &context);
 } // end namespace swift
 
 #endif

lib/AST/AvailabilityConstraint.cpp

@@ -12,6 +12,9 @@
 
 #include "swift/AST/AvailabilityConstraint.h"
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/AvailabilityContext.h"
+#include "swift/AST/AvailabilityInference.h"
+#include "swift/AST/Decl.h"
 
 using namespace swift;
 
@@ -51,3 +54,136 @@ bool AvailabilityConstraint::isActiveForRuntimeQueries(ASTContext &ctx) const {
                                  /*forTargetVariant=*/false,
                                  /*forRuntimeQuery=*/true);
 }
+
+static bool
+isInsideCompatibleUnavailableDeclaration(const Decl *decl,
+                                         const SemanticAvailableAttr &attr,
+                                         const AvailabilityContext &context) {
+  if (!context.isUnavailable())
+    return false;
+
+  if (!attr.isUnconditionallyUnavailable())
+    return false;
+
+  // Refuse calling universally unavailable functions from unavailable code,
+  // but allow the use of types.
+  auto domain = attr.getDomain();
+  if (!isa<TypeDecl>(decl) && !isa<ExtensionDecl>(decl)) {
+    if (domain.isUniversal() || domain.isSwiftLanguage())
+      return false;
+  }
+
+  return context.containsUnavailableDomain(domain);
+}
+
+std::optional<AvailabilityConstraint>
+swift::getAvailabilityConstraintForAttr(const Decl *decl,
+                                        const SemanticAvailableAttr &attr,
+                                        const AvailabilityContext &context) {
+  if (isInsideCompatibleUnavailableDeclaration(decl, attr, context))
+    return std::nullopt;
+
+  if (attr.isUnconditionallyUnavailable())
+    return AvailabilityConstraint::forAlwaysUnavailable(attr);
+
+  auto &ctx = decl->getASTContext();
+  auto deploymentVersion = attr.getActiveVersion(ctx);
+  auto deploymentRange =
+      AvailabilityRange(VersionRange::allGTE(deploymentVersion));
+  std::optional<llvm::VersionTuple> obsoletedVersion = attr.getObsoleted();
+
+  {
+    StringRef obsoletedPlatform;
+    llvm::VersionTuple remappedObsoletedVersion;
+    if (AvailabilityInference::updateObsoletedPlatformForFallback(
+            attr, ctx, obsoletedPlatform, remappedObsoletedVersion))
+      obsoletedVersion = remappedObsoletedVersion;
+  }
+
+  if (obsoletedVersion && *obsoletedVersion <= deploymentVersion)
+    return AvailabilityConstraint::forObsoleted(attr);
+
+  AvailabilityRange introducedRange = attr.getIntroducedRange(ctx);
+
+  // FIXME: [availability] Expand this to cover custom versioned domains
+  if (attr.isPlatformSpecific()) {
+    if (!context.getPlatformRange().isContainedIn(introducedRange))
+      return AvailabilityConstraint::forIntroducedInNewerVersion(attr);
+  } else if (!deploymentRange.isContainedIn(introducedRange)) {
+    return AvailabilityConstraint::forRequiresVersion(attr);
+  }
+
+  return std::nullopt;
+}
+
+/// Returns the most specific platform domain from the availability attributes
+/// attached to \p decl or `std::nullopt` if there are none. Platform specific
+/// `@available` attributes for other platforms should be ignored. For example,
+/// if a declaration has attributes for both iOS and macCatalyst, only the
+/// macCatalyst attributes take effect when compiling for a macCatalyst target.
+static std::optional<AvailabilityDomain>
+activePlatformDomainForDecl(const Decl *decl) {
+  std::optional<AvailabilityDomain> activeDomain;
+  for (auto attr :
+       decl->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto domain = attr.getDomain();
+    if (!domain.isPlatform())
+      continue;
+
+    if (activeDomain && domain.contains(*activeDomain))
+      continue;
+
+    activeDomain.emplace(domain);
+  }
+
+  return activeDomain;
+}
+
+static void
+getAvailabilityConstraintsForDecl(DeclAvailabilityConstraints &constraints,
+                                  const Decl *decl,
+                                  const AvailabilityContext &context) {
+  auto activePlatformDomain = activePlatformDomainForDecl(decl);
+
+  for (auto attr :
+       decl->getSemanticAvailableAttrs(/*includingInactive=*/false)) {
+    auto domain = attr.getDomain();
+    if (domain.isPlatform() && activePlatformDomain &&
+        !activePlatformDomain->contains(domain))
+      continue;
+
+    if (auto constraint =
+            swift::getAvailabilityConstraintForAttr(decl, attr, context))
+      constraints.addConstraint(*constraint);
+  }
+}
+
+DeclAvailabilityConstraints
+swift::getAvailabilityConstraintsForDecl(const Decl *decl,
+                                         const AvailabilityContext &context) {
+  DeclAvailabilityConstraints constraints;
+
+  // Generic parameters are always available.
+  if (isa<GenericTypeParamDecl>(decl))
+    return constraints;
+
+  decl = abstractSyntaxDeclForAvailableAttribute(decl);
+
+  getAvailabilityConstraintsForDecl(constraints, decl, context);
+
+  // If decl is an extension member, query the attributes of the extension, too.
+  //
+  // Skip decls imported from Clang, though, as they could be associated to the
+  // wrong extension and inherit unavailability incorrectly. ClangImporter
+  // associates Objective-C protocol members to the first category where the
+  // protocol is directly or indirectly adopted, no matter its availability
+  // and the availability of other categories. rdar://problem/53956555
+  if (decl->getClangNode())
+    return constraints;
+
+  auto parent = AvailabilityInference::parentDeclForInferredAvailability(decl);
+  if (auto extension = dyn_cast_or_null<ExtensionDecl>(parent))
+    getAvailabilityConstraintsForDecl(constraints, extension, context);
+
+  return constraints;
+}

test/embedded/availability.swift

@@ -17,7 +17,7 @@ public func unavailable_in_embedded() { }
 
 @available(*, unavailable, message: "always unavailable")
 public func universally_unavailable() { }
-// expected-note@-1 3 {{'universally_unavailable()' has been explicitly marked unavailable here}}
+// expected-note@-1 4 {{'universally_unavailable()' has been explicitly marked unavailable here}}
 
 @_unavailableInEmbedded
 public func unused() { } // no error
@@ -35,34 +35,55 @@ public func has_universally_unavailable_overload(_ s1: S1) { }
 
 public func has_universally_unavailable_overload(_ s2: S2) { }
 
+public struct Available {}
+
+@_unavailableInEmbedded
+extension Available {
+  public func unavailable_in_embedded_method( // expected-note {{'unavailable_in_embedded_method' has been explicitly marked unavailable here}}
+    _ uie: UnavailableInEmbedded,
+    _ uu: UniverallyUnavailable,
+    _ a: Available,
+  ) {
+    unavailable_in_embedded()
+    universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
+    a.unavailable_in_embedded_method(uie, uu, a)
+  }
+}
+
 public func available(
   _ uie: UnavailableInEmbedded, // expected-error {{'UnavailableInEmbedded' is unavailable: unavailable in embedded Swift}}
-  _ uu: UniverallyUnavailable // expected-error {{'UniverallyUnavailable' is unavailable: always unavailable}}
+  _ uu: UniverallyUnavailable, // expected-error {{'UniverallyUnavailable' is unavailable: always unavailable}}
+  _ a: Available,
 ) {
   unavailable_in_embedded() // expected-error {{'unavailable_in_embedded()' is unavailable: unavailable in embedded Swift}}
   universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
+  a.unavailable_in_embedded_method(uie, uu, a) // expected-error {{'unavailable_in_embedded_method' is unavailable: unavailable in embedded Swift}}
   has_unavailable_in_embedded_overload(.init())
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }
 
 @_unavailableInEmbedded
 public func also_unavailable_in_embedded(
   _ uie: UnavailableInEmbedded, // OK
-  _ uu: UniverallyUnavailable // OK
+  _ uu: UniverallyUnavailable, // OK
+  _ a: Available,
 ) {
   unavailable_in_embedded() // OK
   universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
+  a.unavailable_in_embedded_method(uie, uu, a)
   has_unavailable_in_embedded_overload(.init()) // expected-error {{ambiguous use of 'init()'}}
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }
 
 @available(*, unavailable)
 public func also_universally_unavailable(
   _ uie: UnavailableInEmbedded, // OK
-  _ uu: UniverallyUnavailable // OK
+  _ uu: UniverallyUnavailable, // OK
+  _ a: Available,
 ) {
   unavailable_in_embedded()
   universally_unavailable() // expected-error {{'universally_unavailable()' is unavailable: always unavailable}}
+  a.unavailable_in_embedded_method(uie, uu, a)
   has_unavailable_in_embedded_overload(.init()) // expected-error {{ambiguous use of 'init()'}}
   has_universally_unavailable_overload(.init()) // not ambiguous, selects available overload
 }