AST/SILGen: Make availability ranges stored by PoundAvailableInfo optional.

Rather than representing a missing availability range on `PoundAvailableInfo`
with a default-constructed `AvailabilityRange` (empty), store the ranges as
optionals instead. This allows an empty range to represent an availability
condition which is known to be false at compile time, which will be necessary
when generating SIL for `if #available` queries that check custom availability
domains.

Author: tshortli

include/swift/AST/Stmt.h

@@ -482,15 +482,15 @@ class alignas(8) PoundAvailableInfo final :
 
   /// The version range when this query will return true. This value is
   /// filled in by Sema.
-  VersionRange AvailableRange;
+  std::optional<VersionRange> AvailableRange;
 
   /// For zippered builds, this is the version range for the target variant
   /// that must hold for the query to return true. For example, when
   /// compiling with target x86_64-macosx10.15 and target-variant
   /// x86_64-ios13.0 a query of #available(macOS 10.22, iOS 20.0, *) will
   /// have a variant range of [20.0, +inf).
   /// This is filled in by Sema.
-  VersionRange VariantAvailableRange;
+  std::optional<VersionRange> VariantAvailableRange;
 
   struct {
     unsigned isInvalid : 1;
@@ -538,11 +538,13 @@ class alignas(8) PoundAvailableInfo final :
   SourceLoc getLoc() const { return PoundLoc; }
   SourceRange getSourceRange() const { return SourceRange(getStartLoc(),
                                                           getEndLoc()); }
-  
-  const VersionRange &getAvailableRange() const { return AvailableRange; }
+
+  std::optional<VersionRange> getAvailableRange() const {
+    return AvailableRange;
+  }
   void setAvailableRange(const VersionRange &Range) { AvailableRange = Range; }
 
-  const VersionRange &getVariantAvailableRange() const {
+  std::optional<VersionRange> getVariantAvailableRange() const {
     return VariantAvailableRange;
   }
   void setVariantAvailableRange(const VersionRange &Range) {

lib/SILGen/SILGenDecl.cpp

@@ -1939,12 +1939,23 @@ void SILGenFunction::emitStmtCondition(StmtCondition Cond, JumpDest FalseDest,
       // Check the running OS version to determine whether it is in the range
       // specified by elt.
       PoundAvailableInfo *availability = elt.getAvailability();
-      VersionRange OSVersion = availability->getAvailableRange();
+
+      // Creates a boolean literal for availability conditions that have been
+      // evaluated at compile time. Automatically inverts the value for
+      // `#unavailable` queries.
+      auto createBooleanTestLiteral = [&](bool value) {
+        SILType i1 = SILType::getBuiltinIntegerType(1, getASTContext());
+        if (availability->isUnavailability())
+          value = !value;
+        return B.createIntegerLiteral(loc, i1, value);
+      };
+
+      auto versionRange = availability->getAvailableRange();
 
       // The OS version might be left empty if availability checking was
       // disabled. Treat it as always-true in that case.
-      assert(!OSVersion.isEmpty()
-             || getASTContext().LangOpts.DisableAvailabilityChecking);
+      assert(versionRange.has_value() ||
+             getASTContext().LangOpts.DisableAvailabilityChecking);
 
       if (getASTContext().LangOpts.TargetVariant &&
           !getASTContext().LangOpts.DisableAvailabilityChecking) {
@@ -1954,25 +1965,34 @@ void SILGenFunction::emitStmtCondition(StmtCondition Cond, JumpDest FalseDest,
         // into. In a macOS process it will use the macOS version; in an
         // macCatalyst process it will use the iOS version.
 
-        VersionRange VariantOSVersion =
+        auto variantVersionRange =
             elt.getAvailability()->getVariantAvailableRange();
-        assert(!VariantOSVersion.isEmpty());
-        booleanTestValue =
-            emitZipperedOSVersionRangeCheck(loc, OSVersion, VariantOSVersion);
+        assert(variantVersionRange.has_value());
+
+        if (versionRange && variantVersionRange) {
+          booleanTestValue = emitZipperedOSVersionRangeCheck(
+              loc, *versionRange, *variantVersionRange);
+        } else {
+          // Type checking did not fill in versions so as a fallback treat this
+          // condition as trivially true.
+          booleanTestValue = createBooleanTestLiteral(true);
+        }
         break;
       }
 
-      if (OSVersion.isEmpty() || OSVersion.isAll()) {
-        // If there's no check for the current platform, this condition is
-        // trivially true  (or false, for unavailability).
-        SILType i1 = SILType::getBuiltinIntegerType(1, getASTContext());
-        bool value = !availability->isUnavailability();
-        booleanTestValue = B.createIntegerLiteral(loc, i1, value);
+      if (!versionRange) {
+        // Type checking did not fill in version so as a fallback treat this
+        // condition as trivially true.
+        booleanTestValue = createBooleanTestLiteral(true);
+      } else if (versionRange->isAll()) {
+        booleanTestValue = createBooleanTestLiteral(true);
+      } else if (versionRange->isEmpty()) {
+        booleanTestValue = createBooleanTestLiteral(false);
       } else {
         bool isMacCatalyst =
             tripleIsMacCatalystEnvironment(getASTContext().LangOpts.Target);
-        booleanTestValue = emitOSVersionRangeCheck(loc, OSVersion,
-                                                   isMacCatalyst);
+        booleanTestValue =
+            emitOSVersionRangeCheck(loc, versionRange.value(), isMacCatalyst);
         if (availability->isUnavailability()) {
           // If this is an unavailability check, invert the result
           // by emitting a call to Builtin.xor_Int1(lhs, -1).

lib/Sema/MiscDiagnostics.cpp

@@ -3656,9 +3656,18 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         auto condition = elt.getAvailability();
 
         auto availabilityRange = condition->getAvailableRange();
+
+        // Type checking did not set a range for this query (it may be invalid).
+        // Treat the condition as if it were always true.
+        if (!availabilityRange.has_value()) {
+          alwaysAvailableCount++;
+          continue;
+        }
+
         // If there is no lower endpoint it means that the condition has no
         // OS version specification that matches the target platform.
-        if (!availabilityRange.hasLowerEndpoint()) {
+        // FIXME: [availability] Handle empty ranges (never available).
+        if (!availabilityRange->hasLowerEndpoint()) {
           // An inactive #unavailable condition trivially evaluates to false.
           if (condition->isUnavailability()) {
             neverAvailableCount++;
@@ -3671,7 +3680,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
         }
 
         conditions.push_back(
-            {availabilityRange, condition->isUnavailability()});
+            {*availabilityRange, condition->isUnavailability()});
       }
 
       // If there were any conditions that were always false, then this