AST: Return @backDeployed attribute along with version from Decl query.

Also, introduce a convenience on `BackDeployedAttr` for getting its associated
`AvailabilityDomain`.

NFC.

Author: tshortli

include/swift/AST/Attr.h

@@ -2925,7 +2925,7 @@ class BackDeployedAttr : public DeclAttribute {
       : DeclAttribute(DeclAttrKind::BackDeployed, AtLoc, Range, Implicit),
         Platform(Platform), Version(Version) {}
 
-  /// The platform the symbol is available for back deployment on.
+  /// The platform the decl is available for back deployment in.
   const PlatformKind Platform;
 
   /// The earliest platform version that may use the back deployed implementation.
@@ -2934,6 +2934,12 @@ class BackDeployedAttr : public DeclAttribute {
   /// Returns true if this attribute is active given the current platform.
   bool isActivePlatform(const ASTContext &ctx, bool forTargetVariant) const;
 
+  /// Returns the `AvailabilityDomain` that the decl is available for back
+  /// deployment in.
+  AvailabilityDomain getAvailabilityDomain() const {
+    return AvailabilityDomain::forPlatform(Platform);
+  }
+
   static bool classof(const DeclAttribute *DA) {
     return DA->getKind() == DeclAttrKind::BackDeployed;
   }

include/swift/AST/Decl.h

@@ -1115,11 +1115,11 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
   std::optional<llvm::VersionTuple>
   getIntroducedOSVersion(PlatformKind Kind) const;
 
-  /// Returns the OS version in which the decl became ABI as specified by the
-  /// `@backDeployed` attribute.
-  std::optional<llvm::VersionTuple>
-  getBackDeployedBeforeOSVersion(ASTContext &Ctx,
-                                 bool forTargetVariant = false) const;
+  /// Returns the active `@backDeployed` attribute and the `AvailabilityRange`
+  /// in which the decl is available as ABI.
+  std::optional<std::pair<const BackDeployedAttr *, AvailabilityRange>>
+  getBackDeployedAttrAndRange(ASTContext &Ctx,
+                              bool forTargetVariant = false) const;
 
   /// Returns true if the decl has an active `@backDeployed` attribute for the
   /// given context.

lib/AST/Availability.cpp

@@ -365,8 +365,8 @@ bool AvailabilityInference::updateBeforeAvailabilityDomainForFallback(
     const BackDeployedAttr *attr, const ASTContext &ctx,
     AvailabilityDomain &domain, llvm::VersionTuple &platformVer) {
   bool hasRemap = false;
-  auto remappedDomain = AvailabilityDomain::forPlatform(attr->Platform)
-                            .getRemappedDomain(ctx, hasRemap);
+  auto remappedDomain =
+      attr->getAvailabilityDomain().getRemappedDomain(ctx, hasRemap);
   if (!hasRemap)
     return false;
 

lib/AST/Decl.cpp

@@ -607,9 +607,9 @@ Decl::getIntroducedOSVersion(PlatformKind Kind) const {
   return std::nullopt;
 }
 
-std::optional<llvm::VersionTuple>
-Decl::getBackDeployedBeforeOSVersion(ASTContext &Ctx,
-                                     bool forTargetVariant) const {
+std::optional<std::pair<const BackDeployedAttr *, AvailabilityRange>>
+Decl::getBackDeployedAttrAndRange(ASTContext &Ctx,
+                                  bool forTargetVariant) const {
   if (auto *attr = getAttrs().getBackDeployed(Ctx, forTargetVariant)) {
     auto version = attr->Version;
     AvailabilityDomain ignoredDomain;
@@ -618,26 +618,25 @@ Decl::getBackDeployedBeforeOSVersion(ASTContext &Ctx,
 
     // If the remap for fallback resulted in 1.0, then the
     // backdeployment prior to that is not meaningful.
-    if (version == clang::VersionTuple(1, 0, 0, 0))
+    if (version == llvm::VersionTuple(1, 0, 0, 0))
       return std::nullopt;
 
-    return version;
+    return std::make_pair(attr, AvailabilityRange(version));
   }
 
   // Accessors may inherit `@backDeployed`.
   if (auto *AD = dyn_cast<AccessorDecl>(this))
-    return AD->getStorage()->getBackDeployedBeforeOSVersion(Ctx,
-                                                            forTargetVariant);
+    return AD->getStorage()->getBackDeployedAttrAndRange(Ctx, forTargetVariant);
 
   return std::nullopt;
 }
 
 bool Decl::isBackDeployed(ASTContext &Ctx) const {
-  if (getBackDeployedBeforeOSVersion(Ctx))
+  if (getBackDeployedAttrAndRange(Ctx))
     return true;
 
   if (Ctx.LangOpts.TargetVariant) {
-    if (getBackDeployedBeforeOSVersion(Ctx, /*forTargetVariant=*/true))
+    if (getBackDeployedAttrAndRange(Ctx, /*forTargetVariant=*/true))
       return true;
   }
 
@@ -1463,8 +1462,8 @@ AvailabilityRange Decl::getAvailabilityForLinkage() const {
 
   // When computing availability for linkage, use the "before" version from
   // the @backDeployed attribute, if present.
-  if (auto backDeployVersion = getBackDeployedBeforeOSVersion(ctx))
-    return AvailabilityRange{*backDeployVersion};
+  if (auto backDeployedAttrAndRange = getBackDeployedAttrAndRange(ctx))
+    return backDeployedAttrAndRange->second;
 
   auto containingContext = AvailabilityInference::annotatedAvailableRange(this);
   if (containingContext.has_value()) {

lib/SILGen/SILGenAvailability.cpp

@@ -228,14 +228,14 @@ static SILValue emitZipperedBackDeployIfAvailableBooleanTestValue(
   assert(ctx.LangOpts.TargetVariant);
 
   VersionRange OSVersion = VersionRange::all();
-  if (auto version = AFD->getBackDeployedBeforeOSVersion(ctx)) {
-    OSVersion = VersionRange::allGTE(*version);
+  if (auto attrAndRange = AFD->getBackDeployedAttrAndRange(ctx)) {
+    OSVersion = attrAndRange->second.getRawVersionRange();
   }
 
   VersionRange VariantOSVersion = VersionRange::all();
-  if (auto version =
-          AFD->getBackDeployedBeforeOSVersion(ctx, /*forTargetVariant=*/true)) {
-    VariantOSVersion = VersionRange::allGTE(*version);
+  if (auto attrAndRange =
+          AFD->getBackDeployedAttrAndRange(ctx, /*forTargetVariant=*/true)) {
+    VariantOSVersion = attrAndRange->second.getRawVersionRange();
   }
 
   return emitZipperedOSVersionRangeCheck(SGF, loc, OSVersion, VariantOSVersion);
@@ -254,25 +254,26 @@ static void emitBackDeployIfAvailableCondition(SILGenFunction &SGF,
                                                SILLocation loc,
                                                SILBasicBlock *availableBB,
                                                SILBasicBlock *unavailableBB) {
-  if (SGF.getASTContext().LangOpts.TargetVariant) {
+  auto &ctx = SGF.getASTContext();
+  if (ctx.LangOpts.TargetVariant) {
     SILValue booleanTestValue =
         emitZipperedBackDeployIfAvailableBooleanTestValue(
             SGF, AFD, loc, availableBB, unavailableBB);
     SGF.B.createCondBranch(loc, booleanTestValue, availableBB, unavailableBB);
     return;
   }
 
-  auto version = AFD->getBackDeployedBeforeOSVersion(SGF.SGM.getASTContext());
+  auto attrAndRange = AFD->getBackDeployedAttrAndRange(ctx);
   VersionRange OSVersion = VersionRange::empty();
-  if (version.has_value()) {
-    OSVersion = VersionRange::allGTE(*version);
+  if (attrAndRange) {
+    OSVersion = attrAndRange->second.getRawVersionRange();
   }
 
   SILValue booleanTestValue;
   if (OSVersion.isEmpty() || OSVersion.isAll()) {
     // If there's no check for the current platform, this condition is
     // trivially true.
-    SILType i1 = SILType::getBuiltinIntegerType(1, SGF.getASTContext());
+    SILType i1 = SILType::getBuiltinIntegerType(1, ctx);
     booleanTestValue = SGF.B.createIntegerLiteral(loc, i1, 1);
   } else {
     bool isMacCatalyst =
@@ -434,8 +435,8 @@ SILGenFunction::emitIfAvailableQuery(SILLocation loc,
 bool SILGenModule::requiresBackDeploymentThunk(ValueDecl *decl,
                                                ResilienceExpansion expansion) {
   auto &ctx = getASTContext();
-  auto backDeployBeforeVersion = decl->getBackDeployedBeforeOSVersion(ctx);
-  if (!backDeployBeforeVersion)
+  auto attrAndRange = decl->getBackDeployedAttrAndRange(ctx);
+  if (!attrAndRange)
     return false;
 
   switch (expansion) {
@@ -453,8 +454,7 @@ bool SILGenModule::requiresBackDeploymentThunk(ValueDecl *decl,
   // high enough that the ABI implementation of the back deployed declaration is
   // guaranteed to be available.
   auto deploymentAvailability = AvailabilityRange::forDeploymentTarget(ctx);
-  auto declAvailability = AvailabilityRange(*backDeployBeforeVersion);
-  if (deploymentAvailability.isContainedIn(declAvailability))
+  if (deploymentAvailability.isContainedIn(attrAndRange->second))
     return false;
 
   return true;

lib/Sema/TypeCheckAttr.cpp

@@ -5129,8 +5129,8 @@ void AttributeChecker::checkBackDeployedAttrs(
   std::map<PlatformKind, SourceLoc> seenPlatforms;
 
   const BackDeployedAttr *ActiveAttr = nullptr;
-  if (D->getBackDeployedBeforeOSVersion(Ctx))
-    ActiveAttr = D->getAttrs().getBackDeployed(Ctx, false);
+  if (auto AttrAndRange = D->getBackDeployedAttrAndRange(Ctx))
+    ActiveAttr = AttrAndRange->first;
 
   for (auto *Attr : Attrs) {
     // Back deployment only makes sense for public declarations.
@@ -5221,7 +5221,7 @@ void AttributeChecker::checkBackDeployedAttrs(
         D->getLoc(), D->getInnermostDeclContext());
 
     // Unavailable decls cannot be back deployed.
-    auto backDeployedDomain = AvailabilityDomain::forPlatform(Attr->Platform);
+    auto backDeployedDomain = Attr->getAvailabilityDomain();
     if (availability.containsUnavailableDomain(backDeployedDomain)) {
       auto domainForDiagnostics = backDeployedDomain;
       llvm::VersionTuple ignoredVersion;
@@ -5254,7 +5254,7 @@ void AttributeChecker::checkBackDeployedAttrs(
     // fallback could never be executed at runtime.
     if (auto availableRangeAttrPair =
             getSemanticAvailableRangeDeclAndAttr(VD)) {
-      auto beforeDomain = AvailabilityDomain::forPlatform(Attr->Platform);
+      auto beforeDomain = Attr->getAvailabilityDomain();
       auto beforeVersion = Attr->Version;
       auto availableAttr = availableRangeAttrPair.value().first;
       auto introVersion = availableAttr.getIntroduced().value();