Merge pull request #63099 from tshortli/consolidate-availability-from-attr

AST: Consolidate instantiation of `AvailabilityContext` from `AvailabilityAttr`

Author: tshortli

include/swift/AST/Availability.h

@@ -224,6 +224,9 @@ class UnavailabilityReason {
 /// See #unionWith, #intersectWith, and #constrainWith.
 ///
 /// [lattice]: http://mathworld.wolfram.com/Lattice.html
+///
+/// NOTE: Generally you should use the utilities on \c AvailabilityInference
+/// to create an \c AvailabilityContext, rather than creating one directly.
 class AvailabilityContext {
   VersionRange OSVersion;
   llvm::Optional<bool> SPI;
@@ -345,6 +348,13 @@ class AvailabilityInference {
   ///  We assume a declaration without an annotation is always available.
   static AvailabilityContext availableRange(const Decl *D, ASTContext &C);
 
+  /// Returns the availability context for a declaration with the given
+  /// @available attribute.
+  ///
+  /// NOTE: The attribute must be active on the current platform.
+  static AvailabilityContext availableRange(const AvailableAttr *attr,
+                                            ASTContext &C);
+
   /// Returns the attribute that should be used to determine the availability
   /// range of the given declaration, or nullptr if there is none.
   static const AvailableAttr *attrForAnnotatedAvailableRange(const Decl *D,

lib/AST/Availability.cpp

@@ -229,9 +229,7 @@ AvailabilityInference::annotatedAvailableRange(const Decl *D, ASTContext &Ctx) {
   if (!bestAvailAttr)
     return None;
 
-  return AvailabilityContext{
-    VersionRange::allGTE(bestAvailAttr->Introduced.value()),
-    bestAvailAttr->IsSPI};
+  return availableRange(bestAvailAttr, Ctx);
 }
 
 bool Decl::isAvailableAsSPI() const {
@@ -283,11 +281,8 @@ AvailabilityInference::annotatedAvailableRangeForAttr(const SpecializeAttr* attr
       bestAvailAttr = availAttr;
   }
 
-  if (bestAvailAttr) {
-    return AvailabilityContext{
-      VersionRange::allGTE(bestAvailAttr->Introduced.value())
-    };
-  }
+  if (bestAvailAttr)
+    return availableRange(bestAvailAttr, ctx);
 
   return AvailabilityContext::alwaysAvailable();
 }
@@ -320,6 +315,14 @@ AvailabilityContext AvailabilityInference::availableRange(const Decl *D,
   return AvailabilityContext::alwaysAvailable();
 }
 
+AvailabilityContext
+AvailabilityInference::availableRange(const AvailableAttr *attr,
+                                      ASTContext &Ctx) {
+  assert(attr->isActivePlatform(Ctx));
+  return AvailabilityContext{VersionRange::allGTE(attr->Introduced.value()),
+                             attr->IsSPI};
+}
+
 namespace {
 /// Infers the availability required to access a type.
 class AvailabilityInferenceTypeWalker : public TypeWalker {

lib/Sema/TypeCheckAttr.cpp

@@ -1885,8 +1885,8 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
   // is fully contained within that declaration's range. If there is no such
   // enclosing declaration, then there is nothing to check.
   Optional<AvailabilityContext> EnclosingAnnotatedRange;
-  AvailabilityContext AttrRange{
-      VersionRange::allGTE(attr->Introduced.value())};
+  AvailabilityContext AttrRange =
+      AvailabilityInference::availableRange(attr, Ctx);
 
   if (auto *parent = getEnclosingDeclForDecl(D)) {
     if (auto enclosingUnavailable = parent->getSemanticUnavailableAttr()) {
@@ -1904,7 +1904,7 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
       const AvailableAttr *enclosingAttr = enclosingAvailable.value().first;
       const Decl *enclosingDecl = enclosingAvailable.value().second;
       EnclosingAnnotatedRange.emplace(
-          VersionRange::allGTE(enclosingAttr->Introduced.value()));
+          AvailabilityInference::availableRange(enclosingAttr, Ctx));
       if (!AttrRange.isContainedIn(*EnclosingAnnotatedRange)) {
         // Members of extensions of nominal types with available ranges were
         // not diagnosed previously, so only emit a warning in that case.