AST: Adopt SemanticAvailableAttr in AvailabilityConstraint.

Author: tshortli

include/swift/AST/AvailabilityConstraint.h

@@ -60,32 +60,32 @@ class AvailabilityConstraint {
 
 private:
   Kind kind;
-  const AvailableAttr *attr;
+  SemanticAvailableAttr attr;
 
-  AvailabilityConstraint(Kind kind, const AvailableAttr *attr)
+  AvailabilityConstraint(Kind kind, SemanticAvailableAttr attr)
       : kind(kind), attr(attr) {};
 
 public:
   static AvailabilityConstraint
-  forAlwaysUnavailable(const AvailableAttr *attr) {
+  forAlwaysUnavailable(SemanticAvailableAttr attr) {
     return AvailabilityConstraint(Kind::AlwaysUnavailable, attr);
   }
 
-  static AvailabilityConstraint forObsoleted(const AvailableAttr *attr) {
+  static AvailabilityConstraint forObsoleted(SemanticAvailableAttr attr) {
     return AvailabilityConstraint(Kind::Obsoleted, attr);
   }
 
-  static AvailabilityConstraint forRequiresVersion(const AvailableAttr *attr) {
+  static AvailabilityConstraint forRequiresVersion(SemanticAvailableAttr attr) {
     return AvailabilityConstraint(Kind::RequiresVersion, attr);
   }
 
   static AvailabilityConstraint
-  forIntroducedInNewerVersion(const AvailableAttr *attr) {
+  forIntroducedInNewerVersion(SemanticAvailableAttr attr) {
     return AvailabilityConstraint(Kind::IntroducedInNewerVersion, attr);
   }
 
   Kind getKind() const { return kind; }
-  const AvailableAttr *getAttr() const { return attr; }
+  SemanticAvailableAttr getAttr() const { return attr; }
 
   /// Returns the platform that this constraint applies to, or
   /// `PlatformKind::none` if it is not platform specific.

lib/AST/Availability.cpp

@@ -68,7 +68,7 @@ AvailabilityRange AvailabilityRange::forRuntimeTarget(const ASTContext &Ctx) {
 }
 
 PlatformKind AvailabilityConstraint::getPlatform() const {
-  return attr->getPlatform();
+  return attr.getPlatform();
 }
 
 std::optional<AvailabilityRange>
@@ -80,7 +80,7 @@ AvailabilityConstraint::getRequiredNewerAvailabilityRange(
   case Kind::Obsoleted:
     return std::nullopt;
   case Kind::IntroducedInNewerVersion:
-    return AvailabilityInference::availableRange(attr, ctx);
+    return AvailabilityInference::availableRange(attr.getParsedAttr(), ctx);
   }
 }
 
@@ -96,10 +96,10 @@ bool AvailabilityConstraint::isConditionallySatisfiable() const {
 }
 
 bool AvailabilityConstraint::isActiveForRuntimeQueries(ASTContext &ctx) const {
-  if (attr->getPlatform() == PlatformKind::none)
+  if (attr.getPlatform() == PlatformKind::none)
     return true;
 
-  return swift::isPlatformActive(attr->getPlatform(), ctx.LangOpts,
+  return swift::isPlatformActive(attr.getPlatform(), ctx.LangOpts,
                                  /*forTargetVariant=*/false,
                                  /*forRuntimeQuery=*/true);
 }

lib/Sema/TypeCheckAvailability.cpp

@@ -3163,7 +3163,6 @@ swift::getUnsatisfiedAvailabilityConstraint(
                                                  *attr))
       return std::nullopt;
 
-    auto parsedAttr = attr->getParsedAttr();
     switch (attr->getVersionAvailability(ctx)) {
     case AvailableVersionComparison::Available:
     case AvailableVersionComparison::PotentiallyUnavailable:
@@ -3173,20 +3172,20 @@ swift::getUnsatisfiedAvailabilityConstraint(
       if ((attr->isSwiftLanguageModeSpecific() ||
            attr->isPackageDescriptionVersionSpecific()) &&
           attr->getIntroduced().has_value())
-        return AvailabilityConstraint::forRequiresVersion(parsedAttr);
+        return AvailabilityConstraint::forRequiresVersion(*attr);
 
-      return AvailabilityConstraint::forAlwaysUnavailable(parsedAttr);
+      return AvailabilityConstraint::forAlwaysUnavailable(*attr);
 
     case AvailableVersionComparison::Obsoleted:
-      return AvailabilityConstraint::forObsoleted(parsedAttr);
+      return AvailabilityConstraint::forObsoleted(*attr);
     }
   }
 
   // Check whether the declaration is available in a newer platform version.
   auto rangeAndAttr = AvailabilityInference::availableRangeAndAttr(decl);
   if (!availabilityContext.getPlatformRange().isContainedIn(rangeAndAttr.first))
     return AvailabilityConstraint::forIntroducedInNewerVersion(
-        rangeAndAttr.second);
+        decl->getSemanticAvailableAttr(rangeAndAttr.second).value());
 
   return std::nullopt;
 }