AST/Sema: Favor AvailabilityContext over VersionTuple/VersionRange.

For the purposes of availability calculations, direct use of
`llvm::VersionTuple` and `VersionRange` is discouraged, since these fundamental
version representations are divorced from their context. For example, comparing
an iOS platform version to a visionOS platform version is invalid since the
versioning systems of the two platforms differ. Although visionOS inherits
avialability from iOS, an iOS version must be converted to a visionOS version
prior to comparison. In the future, `AvailabilityContext` can be enriched to
carry the information necessary to verify that its algebraic operations are
being performed on compatible values.

NFC.

Author: tshortli

include/swift/AST/Availability.h

@@ -238,7 +238,20 @@ class AvailabilityContext {
   }
 
   /// Returns the range of possible versions required by this context.
-  VersionRange getVersionRange() const { return Range; }
+  VersionRange getRawVersionRange() const { return Range; }
+
+  /// Returns true if there is a version tuple for this context.
+  bool hasMinimumVersion() const { return Range.hasLowerEndpoint(); }
+
+  /// Returns the minimum version required by this context. This convenience
+  /// is meant for debugging, diagnostics, serialization, etc. Use of the set
+  /// algebra operations on `AvailabilityContext` should be preferred over
+  /// direct comparison of raw versions.
+  ///
+  /// Only call when `hasMinimumVersion()` returns true.
+  llvm::VersionTuple getRawMinimumVersion() const {
+    return Range.getLowerEndpoint();
+  }
 
   /// Returns true if \p other makes stronger guarantees than this context.
   ///

lib/ClangImporter/ImportDecl.cpp

@@ -541,7 +541,7 @@ static void applyAvailableAttribute(Decl *decl, AvailabilityContext &info,
                                       /*Message=*/StringRef(),
                                       /*Rename=*/StringRef(),
                                       /*RenameDecl=*/nullptr,
-                                      info.getVersionRange().getLowerEndpoint(),
+                                      info.getRawMinimumVersion(),
                                       /*IntroducedRange*/SourceRange(),
                                       /*Deprecated=*/noVersion,
                                       /*DeprecatedRange*/SourceRange(),
@@ -2798,13 +2798,13 @@ namespace {
       if (auto classDecl = dyn_cast<ClassDecl>(result)) {
         validateForeignReferenceType(decl, classDecl);
 
-        auto ctx = Impl.SwiftContext.getSwift58Availability();
-        if (!ctx.isAlwaysAvailable()) {
-          assert(ctx.getVersionRange().hasLowerEndpoint());
+        auto availability = Impl.SwiftContext.getSwift58Availability();
+        if (!availability.isAlwaysAvailable()) {
+          assert(availability.hasMinimumVersion());
           auto AvAttr = new (Impl.SwiftContext) AvailableAttr(
               SourceLoc(), SourceRange(),
               targetPlatform(Impl.SwiftContext.LangOpts), "", "",
-              /*RenameDecl=*/nullptr, ctx.getVersionRange().getLowerEndpoint(),
+              /*RenameDecl=*/nullptr, availability.getRawMinimumVersion(),
               /*IntroducedRange=*/SourceRange(), {},
               /*DeprecatedRange=*/SourceRange(), {},
               /*ObsoletedRange=*/SourceRange(),
@@ -6615,9 +6615,9 @@ bool SwiftDeclConverter::existingConstructorIsWorse(
     if (!introduced.empty())
       return false;
   } else {
-    VersionRange existingIntroduced = existingAvailability.getVersionRange();
-    if (introduced != existingIntroduced.getLowerEndpoint()) {
-      return introduced < existingIntroduced.getLowerEndpoint();
+    auto existingIntroduced = existingAvailability.getRawMinimumVersion();
+    if (introduced != existingIntroduced) {
+      return introduced < existingIntroduced;
     }
   }
 

lib/IRGen/GenMeta.cpp

@@ -5116,8 +5116,8 @@ diagnoseUnsupportedObjCImplLayout(IRGenModule &IGM, ClassDecl *classDecl,
             field.getVarDecl(),
             diag::attr_objc_implementation_resilient_property_deployment_target,
             prettyPlatformString(targetPlatform(ctx.LangOpts)),
-            currentAvailability.getVersionRange().getLowerEndpoint(),
-            requiredAvailability.getVersionRange().getLowerEndpoint());
+            currentAvailability.getRawMinimumVersion(),
+            requiredAvailability.getRawMinimumVersion());
       else
         diags.diagnose(
             field.getVarDecl(),

lib/Sema/TypeCheckAttr.cpp

@@ -1685,7 +1685,7 @@ visitObjCImplementationAttr(ObjCImplementationAttr *attr) {
           attr->getLocation(),
           diag::attr_objc_implementation_raise_minimum_deployment_target,
           prettyPlatformString(targetPlatform(Ctx.LangOpts)),
-          Ctx.getSwift50Availability().getVersionRange().getLowerEndpoint());
+          Ctx.getSwift50Availability().getRawMinimumVersion());
       if (attr->isEarlyAdopter()) {
         diag.wrapIn(diag::wrap_objc_implementation_will_become_error);
       }
@@ -2210,11 +2210,11 @@ void AttributeChecker::visitAvailableAttr(AvailableAttr *attr) {
                    diag::availability_implicit_decl_here,
                    D->getDescriptiveKind(),
                    prettyPlatformString(targetPlatform(Ctx.LangOpts)),
-                   AttrRange.getVersionRange().getLowerEndpoint());
+                   AttrRange.getRawMinimumVersion());
         diagnose(enclosingDecl->getLoc(),
                  diag::availability_decl_more_than_enclosing_here,
                  prettyPlatformString(targetPlatform(Ctx.LangOpts)),
-                 EnclosingAnnotatedRange->getVersionRange().getLowerEndpoint());
+                 EnclosingAnnotatedRange->getRawMinimumVersion());
       }
     }
   }

lib/Sema/TypeCheckAvailability.cpp

@@ -1119,7 +1119,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
       }
 
       AvailabilityContext NewConstraint = contextForSpec(Spec, false);
-      Query->setAvailableRange(contextForSpec(Spec, true).getVersionRange());
+      Query->setAvailableRange(contextForSpec(Spec, true).getRawVersionRange());
 
       // When compiling zippered for macCatalyst, we need to collect both
       // a macOS version (the target version) and an iOS/macCatalyst version
@@ -1130,7 +1130,7 @@ class TypeRefinementContextBuilder : private ASTWalker {
         AvailabilitySpec *VariantSpec =
             bestActiveSpecForQuery(Query, /*ForTargetVariant*/ true);
         VersionRange VariantRange =
-            contextForSpec(VariantSpec, true).getVersionRange();
+            contextForSpec(VariantSpec, true).getRawVersionRange();
         Query->setVariantAvailableRange(VariantRange);
       }
 
@@ -1857,9 +1857,10 @@ static void findAvailabilityFixItNodes(
 
 /// Emit a diagnostic note and Fix-It to add an @available attribute
 /// on the given declaration for the given version range.
-static void fixAvailabilityForDecl(SourceRange ReferenceRange, const Decl *D,
-                                   const VersionRange &RequiredRange,
-                                   ASTContext &Context) {
+static void
+fixAvailabilityForDecl(SourceRange ReferenceRange, const Decl *D,
+                       const AvailabilityContext &RequiredAvailability,
+                       ASTContext &Context) {
   assert(D);
 
   // Don't suggest adding an @available() to a declaration where we would
@@ -1897,8 +1898,7 @@ static void fixAvailabilityForDecl(SourceRange ReferenceRange, const Decl *D,
   D->diagnose(diag::availability_add_attribute, KindForDiagnostic)
       .fixItInsert(InsertLoc, diag::insert_available_attr,
                    platformString(Target),
-                   RequiredRange.getLowerEndpoint().getAsString(),
-                   OriginalIndent);
+                   RequiredAvailability.getVersionString(), OriginalIndent);
 }
 
 /// In the special case of being in an existing, nontrivial type refinement
@@ -1907,29 +1907,26 @@ static void fixAvailabilityForDecl(SourceRange ReferenceRange, const Decl *D,
 /// version), emit a diagnostic and fixit that narrows the existing TRC
 /// condition to the required range.
 static bool fixAvailabilityByNarrowingNearbyVersionCheck(
-    SourceRange ReferenceRange,
-    const DeclContext *ReferenceDC,
-    const VersionRange &RequiredRange,
-    ASTContext &Context,
+    SourceRange ReferenceRange, const DeclContext *ReferenceDC,
+    const AvailabilityContext &RequiredAvailability, ASTContext &Context,
     InFlightDiagnostic &Err) {
   const TypeRefinementContext *TRC = nullptr;
   (void)TypeChecker::overApproximateAvailabilityAtLocation(ReferenceRange.Start,
                                                            ReferenceDC, &TRC);
   if (!TRC)
     return false;
-  VersionRange RunningRange =
-      TRC->getExplicitAvailabilityInfo().getVersionRange();
-  if (RunningRange.hasLowerEndpoint() &&
-      RequiredRange.hasLowerEndpoint() &&
+
+  AvailabilityContext AvailabilityAtLoc = TRC->getExplicitAvailabilityInfo();
+  if (!AvailabilityAtLoc.isAlwaysAvailable() &&
+      !RequiredAvailability.isAlwaysAvailable() &&
       TRC->getReason() != TypeRefinementContext::Reason::Root &&
-      AvailabilityContext(RequiredRange).isContainedIn(
-                                 AvailabilityContext(RunningRange))) {
+      RequiredAvailability.isContainedIn(AvailabilityAtLoc)) {
 
     // Only fix situations that are "nearby" versions, meaning
     // disagreement on a minor-or-less version (subminor-or-less version for
     // macOS 10.x.y).
-    auto RunningVers = RunningRange.getLowerEndpoint();
-    auto RequiredVers = RequiredRange.getLowerEndpoint();
+    auto RunningVers = AvailabilityAtLoc.getRawMinimumVersion();
+    auto RequiredVers = RequiredAvailability.getRawMinimumVersion();
     auto Platform = targetPlatform(Context.LangOpts);
     if (RunningVers.getMajor() != RequiredVers.getMajor())
       return false;
@@ -1947,7 +1944,7 @@ static bool fixAvailabilityByNarrowingNearbyVersionCheck(
     if (!FixRange.isValid())
       return false;
     // Have found a nontrivial type refinement context-introducer to narrow.
-    Err.fixItReplace(FixRange, RequiredVers.getAsString());
+    Err.fixItReplace(FixRange, RequiredAvailability.getVersionString());
     return true;
   }
   return false;
@@ -1956,7 +1953,7 @@ static bool fixAvailabilityByNarrowingNearbyVersionCheck(
 /// Emit a diagnostic note and Fix-It to add an if #available(...) { } guard
 /// that checks for the given version range around the given node.
 static void fixAvailabilityByAddingVersionCheck(
-    ASTNode NodeToWrap, const VersionRange &RequiredRange,
+    ASTNode NodeToWrap, const AvailabilityContext &RequiredAvailability,
     SourceRange ReferenceRange, ASTContext &Context) {
   // If this is an implicit variable that wraps an expression,
   // let's point to it's initializer. For example, result builder
@@ -2010,9 +2007,8 @@ static void fixAvailabilityByAddingVersionCheck(
             basePlatformForExtensionPlatform(Target))
       Target = *TargetRemovingAppExtension;
 
-    Out << "if #available(" << platformString(Target)
-        << " " << RequiredRange.getLowerEndpoint().getAsString()
-        << ", *) {\n";
+    Out << "if #available(" << platformString(Target) << " "
+        << RequiredAvailability.getVersionString() << ", *) {\n";
 
     Out << OriginalIndent << ExtraIndent << GuardedText << "\n";
 
@@ -2032,7 +2028,7 @@ static void fixAvailabilityByAddingVersionCheck(
 /// requiting the given OS version range.
 static void fixAvailability(SourceRange ReferenceRange,
                             const DeclContext *ReferenceDC,
-                            const VersionRange &RequiredRange,
+                            const AvailabilityContext &RequiredAvailability,
                             ASTContext &Context) {
   if (ReferenceRange.isInvalid())
     return;
@@ -2048,18 +2044,19 @@ static void fixAvailability(SourceRange ReferenceRange,
   // Suggest wrapping in if #available(...) { ... } if possible.
   if (NodeToWrapInVersionCheck.has_value()) {
     fixAvailabilityByAddingVersionCheck(NodeToWrapInVersionCheck.value(),
-                                        RequiredRange, ReferenceRange, Context);
+                                        RequiredAvailability, ReferenceRange,
+                                        Context);
   }
 
   // Suggest adding availability attributes.
   if (FoundMemberDecl) {
-    fixAvailabilityForDecl(ReferenceRange, FoundMemberDecl, RequiredRange,
-                           Context);
+    fixAvailabilityForDecl(ReferenceRange, FoundMemberDecl,
+                           RequiredAvailability, Context);
   }
 
   if (FoundTypeLevelDecl) {
-    fixAvailabilityForDecl(ReferenceRange, FoundTypeLevelDecl, RequiredRange,
-                           Context);
+    fixAvailabilityForDecl(ReferenceRange, FoundTypeLevelDecl,
+                           RequiredAvailability, Context);
   }
 }
 
@@ -2068,20 +2065,18 @@ void TypeChecker::diagnosePotentialUnavailability(
     const DeclContext *ReferenceDC, const AvailabilityContext &Availability) {
   ASTContext &Context = ReferenceDC->getASTContext();
 
-  auto RequiredRange = Availability.getVersionRange();
   {
-    auto Err =
-      Context.Diags.diagnose(
-               ReferenceRange.Start, Diag,
-               prettyPlatformString(targetPlatform(Context.LangOpts)),
-               RequiredRange.getLowerEndpoint());
+    auto Err = Context.Diags.diagnose(
+        ReferenceRange.Start, Diag,
+        prettyPlatformString(targetPlatform(Context.LangOpts)),
+        Availability.getRawMinimumVersion());
 
     // Direct a fixit to the error if an existing guard is nearly-correct
     if (fixAvailabilityByNarrowingNearbyVersionCheck(
-        ReferenceRange, ReferenceDC, RequiredRange, Context, Err))
+            ReferenceRange, ReferenceDC, Availability, Context, Err))
       return;
   }
-  fixAvailability(ReferenceRange, ReferenceDC, RequiredRange, Context);
+  fixAvailability(ReferenceRange, ReferenceDC, Availability, Context);
 }
 
 bool TypeChecker::checkAvailability(SourceRange ReferenceRange,
@@ -2128,7 +2123,6 @@ static Diagnostic getPotentialUnavailabilityDiagnostic(
     bool &IsError) {
   ASTContext &Context = ReferenceDC->getASTContext();
   auto Platform = prettyPlatformString(targetPlatform(Context.LangOpts));
-  auto Version = Availability.getVersionRange().getLowerEndpoint();
 
   if (requiresDeploymentTargetOrEarlier(Availability, Context)) {
     // The required OS version is at or before the deployment target so this
@@ -2139,12 +2133,13 @@ static Diagnostic getPotentialUnavailabilityDiagnostic(
     return Diagnostic(
         IsError ? diag::availability_decl_only_version_newer_for_clients
                 : diag::availability_decl_only_version_newer_for_clients_warn,
-        D, Platform, Version, ReferenceDC->getParentModule());
+        D, Platform, Availability.getRawMinimumVersion(),
+        ReferenceDC->getParentModule());
   }
 
   IsError = true;
   return Diagnostic(diag::availability_decl_only_version_newer, D, Platform,
-                    Version);
+                    Availability.getRawMinimumVersion());
 }
 
 bool TypeChecker::diagnosePotentialUnavailability(
@@ -2153,7 +2148,6 @@ bool TypeChecker::diagnosePotentialUnavailability(
     bool WarnBeforeDeploymentTarget = false) {
   ASTContext &Context = ReferenceDC->getASTContext();
 
-  auto RequiredRange = Availability.getVersionRange();
   bool IsError;
   {
     auto Diag = Context.Diags.diagnose(
@@ -2163,11 +2157,11 @@ bool TypeChecker::diagnosePotentialUnavailability(
 
     // Direct a fixit to the error if an existing guard is nearly-correct
     if (fixAvailabilityByNarrowingNearbyVersionCheck(
-            ReferenceRange, ReferenceDC, RequiredRange, Context, Diag))
+            ReferenceRange, ReferenceDC, Availability, Context, Diag))
       return IsError;
   }
 
-  fixAvailability(ReferenceRange, ReferenceDC, RequiredRange, Context);
+  fixAvailability(ReferenceRange, ReferenceDC, Availability, Context);
   return IsError;
 }
 
@@ -2182,23 +2176,19 @@ void TypeChecker::diagnosePotentialAccessorUnavailability(
   auto &diag = ForInout ? diag::availability_inout_accessor_only_version_newer
                         : diag::availability_decl_only_version_newer;
 
-  auto RequiredRange = Availability.getVersionRange();
   {
-    auto Err =
-      Context.Diags.diagnose(
-               ReferenceRange.Start, diag, Accessor,
-               prettyPlatformString(targetPlatform(Context.LangOpts)),
-               RequiredRange.getLowerEndpoint());
-
+    auto Err = Context.Diags.diagnose(
+        ReferenceRange.Start, diag, Accessor,
+        prettyPlatformString(targetPlatform(Context.LangOpts)),
+        Availability.getRawMinimumVersion());
 
     // Direct a fixit to the error if an existing guard is nearly-correct
-    if (fixAvailabilityByNarrowingNearbyVersionCheck(ReferenceRange,
-                                                     ReferenceDC,
-                                                     RequiredRange, Context, Err))
+    if (fixAvailabilityByNarrowingNearbyVersionCheck(
+            ReferenceRange, ReferenceDC, Availability, Context, Err))
       return;
   }
 
-  fixAvailability(ReferenceRange, ReferenceDC, RequiredRange, Context);
+  fixAvailability(ReferenceRange, ReferenceDC, Availability, Context);
 }
 
 static DiagnosticBehavior
@@ -2226,25 +2216,24 @@ void TypeChecker::diagnosePotentialUnavailability(
     const AvailabilityContext &availability) {
   ASTContext &ctx = dc->getASTContext();
 
-  auto requiredRange = availability.getVersionRange();
   {
     auto type = rootConf->getType();
     auto proto = rootConf->getProtocol()->getDeclaredInterfaceType();
     auto err = ctx.Diags.diagnose(
         loc, diag::conformance_availability_only_version_newer, type, proto,
         prettyPlatformString(targetPlatform(ctx.LangOpts)),
-        requiredRange.getLowerEndpoint());
+        availability.getRawMinimumVersion());
 
     err.warnUntilSwiftVersion(6);
     err.limitBehavior(behaviorLimitForExplicitUnavailability(rootConf, dc));
 
     // Direct a fixit to the error if an existing guard is nearly-correct
-    if (fixAvailabilityByNarrowingNearbyVersionCheck(loc, dc,
-                                                     requiredRange, ctx, err))
+    if (fixAvailabilityByNarrowingNearbyVersionCheck(loc, dc, availability, ctx,
+                                                     err))
       return;
   }
 
-  fixAvailability(loc, dc, requiredRange, ctx);
+  fixAvailability(loc, dc, availability, ctx);
 }
 
 const AvailableAttr *TypeChecker::getDeprecated(const Decl *D) {
@@ -4635,7 +4624,7 @@ static bool declNeedsExplicitAvailability(const Decl *decl) {
 
   // Warn on decls without an introduction version.
   auto safeRangeUnderApprox = AvailabilityInference::availableRange(decl, ctx);
-  return !safeRangeUnderApprox.getVersionRange().hasLowerEndpoint();
+  return safeRangeUnderApprox.isAlwaysAvailable();
 }
 
 void swift::checkExplicitAvailability(Decl *decl) {