Merge pull request swiftlang#83162 from tshortli/misc-availability-cleanups

Miscellaneous availability cleanups

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -23,6 +23,7 @@
 #include "swift/AST/PlatformKindUtils.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/OptionSet.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 
@@ -140,6 +141,8 @@ class AvailabilityConstraint {
   /// Some availability constraints are active for type-checking but cannot
   /// be translated directly into an `if #available(...)` runtime query.
   bool isActiveForRuntimeQueries(const ASTContext &ctx) const;
+
+  void print(raw_ostream &os) const;
 };
 
 /// Represents a set of availability constraints that restrict use of a
@@ -161,6 +164,8 @@ class DeclAvailabilityConstraints {
   using const_iterator = Storage::const_iterator;
   const_iterator begin() const { return constraints.begin(); }
   const_iterator end() const { return constraints.end(); }
+
+  void print(raw_ostream &os) const;
 };
 
 enum class AvailabilityConstraintFlag : uint8_t {
@@ -191,4 +196,21 @@ DeclAvailabilityConstraints getAvailabilityConstraintsForDecl(
     AvailabilityConstraintFlags flags = std::nullopt);
 } // end namespace swift
 
+namespace llvm {
+
+inline llvm::raw_ostream &
+operator<<(llvm::raw_ostream &os,
+           const swift::AvailabilityConstraint &constraint) {
+  constraint.print(os);
+  return os;
+}
+
+inline llvm::raw_ostream &
+operator<<(llvm::raw_ostream &os,
+           const swift::DeclAvailabilityConstraints &constraints) {
+  constraints.print(os);
+  return os;
+}
+
+} // end namespace llvm
 #endif

include/swift/AST/AvailabilityContext.h

@@ -23,6 +23,7 @@
 #include "swift/AST/PlatformKindUtils.h"
 #include "swift/Basic/Debug.h"
 #include "swift/Basic/LLVM.h"
+#include "llvm/Support/raw_ostream.h"
 #include <optional>
 
 namespace swift {
@@ -148,4 +149,14 @@ class AvailabilityContext {
 
 } // end namespace swift
 
+namespace llvm {
+
+inline llvm::raw_ostream &
+operator<<(llvm::raw_ostream &os, const swift::AvailabilityContext &context) {
+  context.print(os);
+  return os;
+}
+
+} // end namespace llvm
+
 #endif

include/swift/AST/AvailabilityDomain.h

@@ -28,6 +28,7 @@
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 #include "llvm/ADT/PointerUnion.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 class ASTContext;
@@ -521,6 +522,12 @@ struct PointerLikeTypeTraits<swift::AvailabilityDomainOrIdentifier> {
   };
 };
 
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const swift::AvailabilityDomain &domain) {
+  domain.print(os);
+  return os;
+}
+
 } // end namespace llvm
 
 #endif

include/swift/AST/AvailabilityInference.h

@@ -31,10 +31,6 @@ class SemanticAvailableAttr;
 
 class AvailabilityInference {
 public:
-  /// Returns the decl that should be considered the parent decl of the given
-  /// decl when looking for inherited availability annotations.
-  static const Decl *parentDeclForInferredAvailability(const Decl *D);
-
   /// Infers the common availability required to access an array of
   /// declarations and adds attributes reflecting that availability
   /// to ToDecl.
@@ -47,9 +43,6 @@ class AvailabilityInference {
   /// Returns the range of platform versions in which the decl is available.
   static AvailabilityRange availableRange(const Decl *D);
 
-  /// Returns true is the declaration is `@_spi_available`.
-  static bool isAvailableAsSPI(const Decl *D);
-
   /// Returns the context for which the declaration
   /// is annotated as available, or None if the declaration
   /// has no availability annotation.

include/swift/AST/AvailabilityRange.h

@@ -21,7 +21,7 @@
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/VersionTuple.h"
-#include <optional>
+#include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 class ASTContext;
@@ -317,11 +317,20 @@ class AvailabilityRange {
 
   /// Returns a representation of this range as a string for debugging purposes.
   std::string getAsString() const {
-    return "AvailabilityRange(" + getVersionString() + ")";
+    return "AvailabilityRange(" + getVersionDescription() + ")";
   }
 
-  /// Returns a representation of the raw version range as a string for
+  /// Returns a representation of the version range as a string for
   /// debugging purposes.
+  std::string getVersionDescription() const {
+    if (Range.hasLowerEndpoint())
+      return Range.getLowerEndpoint().getAsString();
+    else
+      return Range.isEmpty() ? "never" : "always";
+  }
+
+  /// Returns a string representation of the raw version range. It is an error
+  /// to call this if the range is "always" or "never".
   std::string getVersionString() const {
     ASSERT(Range.hasLowerEndpoint());
     return Range.getLowerEndpoint().getAsString();
@@ -330,4 +339,20 @@ class AvailabilityRange {
 
 } // end namespace swift
 
+namespace llvm {
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const swift::VersionRange &range) {
+  os << range.getAsString();
+  return os;
+}
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const swift::AvailabilityRange &range) {
+  os << range.getAsString();
+  return os;
+}
+
+} // namespace llvm
+
 #endif

include/swift/AST/AvailabilitySpec.h

@@ -27,6 +27,7 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/iterator_range.h"
 #include "llvm/Support/VersionTuple.h"
+#include "llvm/Support/raw_ostream.h"
 
 namespace swift {
 class ASTContext;
@@ -241,4 +242,20 @@ class AvailabilityMacroMap {
 
 } // end namespace swift
 
+namespace llvm {
+
+inline llvm::raw_ostream &operator<<(llvm::raw_ostream &os,
+                                     const swift::AvailabilitySpec *spec) {
+  spec->print(os);
+  return os;
+}
+
+inline llvm::raw_ostream &
+operator<<(llvm::raw_ostream &os, const swift::SemanticAvailabilitySpec &spec) {
+  spec.print(os);
+  return os;
+}
+
+} // end namespace llvm
+
 #endif

include/swift/AST/Decl.h

@@ -1521,6 +1521,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   /// compatibility mode.
   bool requiresUnavailableDeclABICompatibilityStubs() const;
 
+  /// Returns the decl that should be considered the parent decl when looking
+  /// for inherited availability annotations.
+  const Decl *parentDeclForAvailability() const;
+
   // List the SPI groups declared with @_spi or inherited by this decl.
   //
   // SPI groups are inherited from the parent contexts only if the local decl

lib/AST/Availability.cpp

@@ -197,7 +197,7 @@ void AvailabilityInference::applyInferredAvailableAttrs(
 
       // Walk up the enclosing declaration hierarchy to make sure we aren't
       // missing any inherited attributes.
-      D = AvailabilityInference::parentDeclForInferredAvailability(D);
+      D = D->parentDeclForAvailability();
     } while (D);
   }
 
@@ -213,32 +213,31 @@ void AvailabilityInference::applyInferredAvailableAttrs(
 
 /// Returns the decl that should be considered the parent decl of the given decl
 /// when looking for inherited availability annotations.
-const Decl *
-AvailabilityInference::parentDeclForInferredAvailability(const Decl *D) {
-  if (auto *AD = dyn_cast<AccessorDecl>(D))
+const Decl *Decl::parentDeclForAvailability() const {
+  if (auto *AD = dyn_cast<AccessorDecl>(this))
     return AD->getStorage();
 
-  if (auto *ED = dyn_cast<ExtensionDecl>(D)) {
+  if (auto *ED = dyn_cast<ExtensionDecl>(this)) {
     if (auto *NTD = ED->getExtendedNominal())
       return NTD;
   }
 
-  if (auto *PBD = dyn_cast<PatternBindingDecl>(D)) {
+  if (auto *PBD = dyn_cast<PatternBindingDecl>(this)) {
     if (PBD->getNumPatternEntries() < 1)
       return nullptr;
 
     return PBD->getAnchoringVarDecl(0);
   }
 
-  if (auto *OTD = dyn_cast<OpaqueTypeDecl>(D))
+  if (auto *OTD = dyn_cast<OpaqueTypeDecl>(this))
     return OTD->getNamingDecl();
 
   // Clang decls may be inaccurately parented rdar://53956555
-  if (D->hasClangNode())
+  if (hasClangNode())
     return nullptr;
 
   // Availability is inherited from the enclosing context.
-  return D->getDeclContext()->getInnermostDeclarationDeclContext();
+  return getDeclContext()->getInnermostDeclarationDeclContext();
 }
 
 /// Returns true if the introduced version in \p newAttr should be used instead
@@ -408,7 +407,10 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D) {
 }
 
 bool Decl::isAvailableAsSPI() const {
-  return AvailabilityInference::isAvailableAsSPI(this);
+  if (auto attr = getAvailableAttrForPlatformIntroduction())
+    return attr->isSPI();
+
+  return false;
 }
 
 SemanticAvailableAttributes
@@ -696,10 +698,8 @@ DeclRuntimeAvailability
 DeclRuntimeAvailabilityRequest::evaluate(Evaluator &evaluator,
                                          const Decl *decl) const {
   auto inherited = DeclRuntimeAvailability::PotentiallyAvailable;
-  if (auto *parent =
-          AvailabilityInference::parentDeclForInferredAvailability(decl)) {
+  if (auto *parent = decl->parentDeclForAvailability())
     inherited = getDeclRuntimeAvailability(parent);
-  }
 
   // If the inherited runtime availability is already maximally unavailable
   // then skip computing unavailability for this declaration.
@@ -785,8 +785,7 @@ Decl::getAvailableAttrForPlatformIntroduction(bool checkExtension) const {
   if (!checkExtension)
     return std::nullopt;
 
-  if (auto parent =
-          AvailabilityInference::parentDeclForInferredAvailability(this)) {
+  if (auto parent = parentDeclForAvailability()) {
     if (auto *ED = dyn_cast<ExtensionDecl>(parent)) {
       if (auto attr = getDeclAvailableAttrForPlatformIntroduction(ED))
         return attr;
@@ -804,13 +803,6 @@ AvailabilityRange AvailabilityInference::availableRange(const Decl *D) {
   return AvailabilityRange::alwaysAvailable();
 }
 
-bool AvailabilityInference::isAvailableAsSPI(const Decl *D) {
-  if (auto attr = D->getAvailableAttrForPlatformIntroduction())
-    return attr->isSPI();
-
-  return false;
-}
-
 std::optional<SemanticAvailableAttr>
 SemanticAvailableAttrRequest::evaluate(swift::Evaluator &evaluator,
                                        const AvailableAttr *attr,

lib/AST/AvailabilityConstraint.cpp

@@ -13,7 +13,6 @@
 #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;
@@ -45,6 +44,27 @@ bool AvailabilityConstraint::isActiveForRuntimeQueries(
                                  /*forRuntimeQuery=*/true);
 }
 
+void AvailabilityConstraint::print(llvm::raw_ostream &os) const {
+  os << "AvailabilityConstraint(";
+  getAttr().getDomain().print(os);
+  os << ", ";
+
+  switch (getReason()) {
+  case Reason::UnconditionallyUnavailable:
+    os << "unavailable";
+    break;
+  case Reason::Obsoleted:
+    os << "obsoleted: " << getAttr().getObsoleted().value();
+    break;
+  case Reason::UnavailableForDeployment:
+  case Reason::PotentiallyUnavailable:
+    os << "introduced: " << getAttr().getIntroduced().value();
+    break;
+  }
+
+  os << ")";
+}
+
 static bool constraintIsStronger(const AvailabilityConstraint &lhs,
                                  const AvailabilityConstraint &rhs) {
   DEBUG_ASSERT(lhs.getDomain() == rhs.getDomain());
@@ -117,6 +137,17 @@ DeclAvailabilityConstraints::getPrimaryConstraint() const {
   return result;
 }
 
+void DeclAvailabilityConstraints::print(llvm::raw_ostream &os) const {
+  os << "{\n";
+  llvm::interleave(
+      constraints,
+      [&os](const AvailabilityConstraint &constraint) {
+        os << "  " << constraint;
+      },
+      [&os] { os << ",\n"; });
+  os << "\n}";
+}
+
 static bool canIgnoreConstraintInUnavailableContexts(
     const Decl *decl, const AvailabilityConstraint &constraint,
     const AvailabilityConstraintFlags flags) {
@@ -293,9 +324,10 @@ swift::getAvailabilityConstraintsForDecl(const Decl *decl,
   if (decl->getClangNode())
     return constraints;
 
-  auto parent = AvailabilityInference::parentDeclForInferredAvailability(decl);
+  auto parent = decl->parentDeclForAvailability();
   if (auto extension = dyn_cast_or_null<ExtensionDecl>(parent))
     getAvailabilityConstraintsForDecl(constraints, extension, context, flags);
 
   return constraints;
 }
+

lib/AST/Decl.cpp

@@ -591,8 +591,7 @@ const Decl *Decl::getInnermostDeclWithAvailability() const {
   if (getAttrs().hasAttribute<AvailableAttr>())
     return this;
 
-  if (auto parent =
-          AvailabilityInference::parentDeclForInferredAvailability(this))
+  if (auto parent = parentDeclForAvailability())
     return parent->getInnermostDeclWithAvailability();
 
   return nullptr;
@@ -1492,7 +1491,7 @@ AvailabilityRange Decl::getAvailabilityForLinkage() const {
     return *containingContext;
   }
 
-  // FIXME: Adopt AvailabilityInference::parentDeclForInferredAvailability()
+  // FIXME: Adopt Decl::parentDeclForAvailability()
   // here instead of duplicating the logic.
   if (auto *accessor = dyn_cast<AccessorDecl>(this))
     return accessor->getStorage()->getAvailabilityForLinkage();