AST: Teach AvailabilityContext to represent version-less availability.

This enables potential unavailability diagnostics to be emitted for decls that
are only available in a version-less domain.

Author: tshortli

include/swift/AST/AvailabilityContext.h

@@ -64,8 +64,15 @@ class AvailabilityContext {
 
   /// Returns the range of platform versions which may execute code in the
   /// availability context, starting at its introduction version.
+  // FIXME: [availability] Remove; superseded by getAvailableRange().
   AvailabilityRange getPlatformRange() const;
 
+  /// Returns the range which is available for `domain` in this context. If
+  /// there are not any constraints established for `domain`, returns
+  /// `std::nullopt`.
+  std::optional<AvailabilityRange>
+  getAvailabilityRange(AvailabilityDomain domain, const ASTContext &ctx) const;
+
   /// Returns true if this context contains any unavailable domains.
   bool isUnavailable() const;
 
@@ -80,9 +87,15 @@ class AvailabilityContext {
                             const ASTContext &ctx);
 
   /// Constrain the platform availability range with `platformRange`.
+  // FIXME: [availability] Remove; superseded by constrainWithAvailableRange().
   void constrainWithPlatformRange(const AvailabilityRange &platformRange,
                                   const ASTContext &ctx);
 
+  /// Constrain the available range for `domain` by `range`.
+  void constrainWithAvailabilityRange(const AvailabilityRange &range,
+                                      AvailabilityDomain domain,
+                                      const ASTContext &ctx);
+
   /// Constrain the context by adding \p domain to the set of unavailable
   /// domains.
   void constrainWithUnavailableDomain(AvailabilityDomain domain,

include/swift/AST/AvailabilityContextStorage.h

@@ -43,6 +43,8 @@ class AvailabilityContext::DomainInfo final {
   AvailabilityRange getRange() const { return range; }
   bool isUnavailable() const { return range.isKnownUnreachable(); }
 
+  bool constrainRange(const AvailabilityRange &range);
+
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddPointer(domain.getOpaqueValue());
     range.getRawVersionRange().Profile(ID);

include/swift/AST/AvailabilityDomain.h

@@ -209,13 +209,24 @@ class AvailabilityDomain final {
   /// version ranges.
   bool isVersioned() const;
 
+  /// Returns true if availability of the domain can be refined using
+  /// `@available` attributes and `if #available` queries. If not, then the
+  /// domain's availability is fixed by compilation settings. For example,
+  /// macOS platform availability supports contextual refinement, whereas Swift
+  /// language availability does not.
+  bool supportsContextRefinement() const;
+
   /// Returns true if the domain supports `#available`/`#unavailable` queries.
   bool supportsQueries() const;
 
   /// Returns true if this domain is considered active in the current
   /// compilation context.
   bool isActive(const ASTContext &ctx) const;
 
+  /// Returns true if this domain is a platform domain that is contained by the
+  /// set of active platform-specific domains.
+  bool isActiveForTargetPlatform(const ASTContext &ctx) const;
+
   /// Returns the minimum available range for the attribute's domain. For
   /// example, for the domain of the platform that compilation is targeting,
   /// this will be the deployment target. For the Swift language domain, this

lib/AST/AvailabilityConstraint.cpp

@@ -140,27 +140,33 @@ static std::optional<AvailabilityConstraint>
 getAvailabilityConstraintForAttr(const Decl *decl,
                                  const SemanticAvailableAttr &attr,
                                  const AvailabilityContext &context) {
+  // Is the decl unconditionally unavailable?
   if (attr.isUnconditionallyUnavailable())
     return AvailabilityConstraint::unconditionallyUnavailable(attr);
 
   auto &ctx = decl->getASTContext();
-  auto deploymentRange = attr.getDomain().getDeploymentRange(ctx);
+  auto domain = attr.getDomain();
+  auto deploymentRange = domain.getDeploymentRange(ctx);
 
   // Is the decl obsoleted in the deployment context?
   if (auto obsoletedRange = attr.getObsoletedRange(ctx)) {
     if (deploymentRange && deploymentRange->isContainedIn(*obsoletedRange))
       return AvailabilityConstraint::obsoleted(attr);
   }
 
+  // Is the decl not yet introduced in the local context?
   if (auto introducedRange = attr.getIntroducedRange(ctx)) {
-    // FIXME: [availability] Expand this to cover custom versioned domains
-    if (attr.isPlatformSpecific()) {
-      if (!context.getPlatformRange().isContainedIn(*introducedRange))
+    if (domain.supportsContextRefinement()) {
+      auto availableRange = context.getAvailabilityRange(domain, ctx);
+      if (!availableRange || !availableRange->isContainedIn(*introducedRange))
         return AvailabilityConstraint::potentiallyUnavailable(attr);
-    } else if (deploymentRange &&
-               !deploymentRange->isContainedIn(*introducedRange)) {
-      return AvailabilityConstraint::unavailableForDeployment(attr);
+
+      return std::nullopt;
     }
+
+    // Is the decl not yet introduced in the deployment context?
+    if (deploymentRange && !deploymentRange->isContainedIn(*introducedRange))
+      return AvailabilityConstraint::unavailableForDeployment(attr);
   }
 
   // FIXME: [availability] Model deprecation as an availability constraint.

lib/AST/AvailabilityContext.cpp

@@ -44,60 +44,96 @@ static bool constrainRange(AvailabilityRange &existing,
   return true;
 }
 
-/// Returns true if `domain` is not already contained in `domainInfos` as an
-/// unavailable domain. Also, removes domains from `unavailableDomains` that are
-/// contained in `domain`.
-static bool shouldConstrainUnavailableDomains(
-    AvailabilityDomain domain,
-    llvm::SmallVectorImpl<AvailabilityContext::DomainInfo> &domainInfos) {
-  bool didRemove = false;
-  for (auto iter = domainInfos.rbegin(), end = domainInfos.rend(); iter != end;
-       ++iter) {
-    auto const &domainInfo = *iter;
-    auto existingDomain = domainInfo.getDomain();
-
-    if (!domainInfo.isUnavailable())
+/// Returns true if `domainInfos` will be constrained by merging the domain
+/// availability represented by `otherDomainInfo`. Additionally, this function
+/// has a couple of side-effects:
+///
+///   - If any existing domain availability ought to be constrained by
+///     `otherDomainInfo` then that value will be updated in place.
+///   - If any existing value in `domainInfos` should be replaced when
+///     `otherDomainInfo` is added, then that existing value is removed
+///     and `otherDomainInfo` is appended to `domainInfosToAdd`.
+///
+static bool constrainDomainInfos(
+    AvailabilityContext::DomainInfo otherDomainInfo,
+    llvm::SmallVectorImpl<AvailabilityContext::DomainInfo> &domainInfos,
+    llvm::SmallVectorImpl<AvailabilityContext::DomainInfo> &domainInfosToAdd) {
+  bool isConstrained = false;
+  bool shouldAdd = true;
+  auto otherDomain = otherDomainInfo.getDomain();
+  auto end = domainInfos.rend();
+
+  // Iterate over domainInfos in reverse order to allow items to be removed
+  // during iteration.
+  for (auto iter = domainInfos.rbegin(); iter != end; ++iter) {
+    auto &domainInfo = *iter;
+    auto domain = domainInfo.getDomain();
+
+    // We found an existing available range for the domain. Constrain it if
+    // necessary.
+    if (domain == otherDomain) {
+      shouldAdd = false;
+      isConstrained |= domainInfo.constrainRange(otherDomainInfo.getRange());
       continue;
+    }
 
-    // Check if the domain is already unavailable.
-    if (existingDomain.contains(domain)) {
-      ASSERT(!didRemove); // This would indicate that the context is malformed.
+    // Check whether an existing unavailable domain contains the domain that
+    // would be added. If so, there's nothing to do because the availability of
+    // the domain is already as constrained as it can be.
+    if (domainInfo.isUnavailable() && domain.contains(otherDomain)) {
+      DEBUG_ASSERT(!isConstrained);
       return false;
     }
 
-    // Check if the existing domain would be absorbed by the new domain.
-    if (domain.contains(existingDomain)) {
+    // If the domain that will be added is unavailable, check whether the
+    // existing domain is contained within it. If it is, availability for the
+    // existing domain should be removed because it has been superseded.
+    if (otherDomainInfo.isUnavailable() && otherDomain.contains(domain)) {
       domainInfos.erase((iter + 1).base());
-      didRemove = true;
+      isConstrained = true;
     }
   }
 
-  return true;
+  // If the new domain availability isn't already covered by an item in
+  // `domainInfos`, then it needs to be added. Defer adding the new domain
+  // availability until later when the entire set of domain infos can be
+  // re-sorted once.
+  if (shouldAdd) {
+    domainInfosToAdd.push_back(otherDomainInfo);
+    return true;
+  }
+
+  return isConstrained;
 }
 
+/// Constrains `domainInfos` by merging them with `otherDomainInfos`. Returns
+/// true if any changes were made to `domainInfos`.
 static bool constrainDomainInfos(
     llvm::SmallVectorImpl<AvailabilityContext::DomainInfo> &domainInfos,
     llvm::ArrayRef<AvailabilityContext::DomainInfo> otherDomainInfos) {
+  bool isConstrained = false;
   llvm::SmallVector<AvailabilityContext::DomainInfo, 4> domainInfosToAdd;
-
   for (auto otherDomainInfo : otherDomainInfos) {
-    if (otherDomainInfo.isUnavailable())
-      if (shouldConstrainUnavailableDomains(otherDomainInfo.getDomain(),
-                                            domainInfos))
-        domainInfosToAdd.push_back(otherDomainInfo);
+    isConstrained |=
+        constrainDomainInfos(otherDomainInfo, domainInfos, domainInfosToAdd);
   }
 
-  if (domainInfosToAdd.size() < 1)
+  if (!isConstrained)
     return false;
 
-  // Add the candidate domain and then re-sort.
+  // Add the new domains and then re-sort.
   for (auto domainInfo : domainInfosToAdd)
     domainInfos.push_back(domainInfo);
 
   llvm::sort(domainInfos, AvailabilityDomainInfoComparator());
   return true;
 }
 
+bool AvailabilityContext::DomainInfo::constrainRange(
+    const AvailabilityRange &otherRange) {
+  return ::constrainRange(range, otherRange);
+}
+
 AvailabilityContext
 AvailabilityContext::forPlatformRange(const AvailabilityRange &range,
                                       const ASTContext &ctx) {
@@ -121,6 +157,23 @@ AvailabilityRange AvailabilityContext::getPlatformRange() const {
   return storage->platformRange;
 }
 
+std::optional<AvailabilityRange>
+AvailabilityContext::getAvailabilityRange(AvailabilityDomain domain,
+                                          const ASTContext &ctx) const {
+  DEBUG_ASSERT(domain.supportsContextRefinement());
+
+  if (domain.isActiveForTargetPlatform(ctx)) {
+    return storage->platformRange;
+  }
+
+  for (auto domainInfo : storage->getDomainInfos()) {
+    if (domain == domainInfo.getDomain() && !domainInfo.isUnavailable())
+      return domainInfo.getRange();
+  }
+
+  return std::nullopt;
+}
+
 bool AvailabilityContext::isUnavailable() const {
   for (auto domainInfo : storage->getDomainInfos()) {
     if (domainInfo.isUnavailable())
@@ -162,16 +215,32 @@ void AvailabilityContext::constrainWithContext(const AvailabilityContext &other,
 }
 
 void AvailabilityContext::constrainWithPlatformRange(
-    const AvailabilityRange &otherPlatformRange, const ASTContext &ctx) {
-
+    const AvailabilityRange &range, const ASTContext &ctx) {
   auto platformRange = storage->platformRange;
-  if (!constrainRange(platformRange, otherPlatformRange))
+  if (!constrainRange(platformRange, range))
     return;
 
   storage = Storage::get(platformRange, storage->isDeprecated,
                          storage->getDomainInfos(), ctx);
 }
 
+void AvailabilityContext::constrainWithAvailabilityRange(
+    const AvailabilityRange &range, AvailabilityDomain domain,
+    const ASTContext &ctx) {
+
+  if (domain.isActiveForTargetPlatform(ctx)) {
+    constrainWithPlatformRange(range, ctx);
+    return;
+  }
+
+  auto domainInfos = storage->copyDomainInfos();
+  if (!constrainDomainInfos(domainInfos, {DomainInfo(domain, range)}))
+    return;
+
+  storage = Storage::get(storage->platformRange, storage->isDeprecated,
+                         domainInfos, ctx);
+}
+
 void AvailabilityContext::constrainWithUnavailableDomain(
     AvailabilityDomain domain, const ASTContext &ctx) {
   auto domainInfos = storage->copyDomainInfos();
@@ -196,6 +265,9 @@ void AvailabilityContext::constrainWithDeclAndPlatformRange(
   bool isDeprecated = storage->isDeprecated;
   isConstrained |= constrainBool(isDeprecated, decl->isDeprecated());
 
+  // Compute the availability constraints for the decl when used in this context
+  // and then map those constraints to domain infos. The result will be merged
+  // into the existing domain infos for this context.
   llvm::SmallVector<DomainInfo, 4> declDomainInfos;
   AvailabilityConstraintFlags flags =
       AvailabilityConstraintFlag::SkipEnclosingExtension;
@@ -211,13 +283,13 @@ void AvailabilityContext::constrainWithDeclAndPlatformRange(
       declDomainInfos.push_back(DomainInfo::unavailable(domain));
       break;
     case AvailabilityConstraint::Reason::PotentiallyUnavailable:
-      DEBUG_ASSERT(domain.isPlatform());
-      if (domain.isPlatform()) {
-        if (auto introducedRange = attr.getIntroducedRange(ctx))
+      if (auto introducedRange = attr.getIntroducedRange(ctx)) {
+        if (domain.isActiveForTargetPlatform(ctx)) {
           isConstrained |= constrainRange(platformRange, *introducedRange);
+        } else {
+          declDomainInfos.push_back({domain, *introducedRange});
+        }
       }
-      // FIXME: [availability] Store other potentially unavailable domains in
-      // domainInfos.
       break;
     }
   }
@@ -285,16 +357,38 @@ void AvailabilityContext::print(llvm::raw_ostream &os) const {
 
 void AvailabilityContext::dump() const { print(llvm::errs()); }
 
-bool AvailabilityContext::verify(const ASTContext &ctx) const {
-  // Domain infos must be sorted to ensure folding set node lookups yield
-  // consistent results.
-  if (!llvm::is_sorted(storage->getDomainInfos(),
-                       AvailabilityDomainInfoComparator()))
-    return false;
+bool verifyDomainInfos(
+    llvm::ArrayRef<AvailabilityContext::DomainInfo> domainInfos) {
+  // Checks that the following invariants hold:
+  //   - The domain infos are sorted using AvailabilityDomainInfoComparator.
+  //   - There is not more than one info per-domain.
+  if (domainInfos.empty())
+    return true;
+
+  AvailabilityDomainInfoComparator compare;
+  auto prev = domainInfos.begin();
+  auto next = prev;
+  auto end = domainInfos.end();
+  for (++next; next != end; prev = next, ++next) {
+    const auto &prevInfo = *prev;
+    const auto &nextInfo = *next;
+
+    if (compare(nextInfo, prevInfo))
+      return false;
+
+    // Since the infos are sorted by domain, infos with the same domain should
+    // be adjacent.
+    if (prevInfo.getDomain() == nextInfo.getDomain())
+      return false;
+  }
 
   return true;
 }
 
+bool AvailabilityContext::verify(const ASTContext &ctx) const {
+  return verifyDomainInfos(storage->getDomainInfos());
+}
+
 void AvailabilityContext::Storage::Profile(
     llvm::FoldingSetNodeID &ID, const AvailabilityRange &platformRange,
     bool isDeprecated,