AST: Build statement condition availability scopes using AvailabilityContext.

Preparation for building availability scopes for `if #available` statements
that query non-platform availability domains.

Author: tshortli

include/swift/AST/AvailabilityContext.h

@@ -99,11 +99,15 @@ class AvailabilityContext {
   void constrainWithContext(const AvailabilityContext &other,
                             const ASTContext &ctx);
 
-  /// Constrain the platform availability range with `platformRange`.
+  /// Constrain the platform version range with `range`.
   // FIXME: [availability] Remove; superseded by constrainWithAvailableRange().
-  void constrainWithPlatformRange(const AvailabilityRange &platformRange,
+  void constrainWithPlatformRange(const AvailabilityRange &range,
                                   const ASTContext &ctx);
 
+  /// Expand the platform version range to contain `range`.
+  void unionWithPlatformRange(const AvailabilityRange &range,
+                              const ASTContext &ctx);
+
   /// Constrain the available range for `domain` by `range`.
   void constrainWithAvailabilityRange(const AvailabilityRange &range,
                                       AvailabilityDomain domain,

include/swift/AST/AvailabilityContextStorage.h

@@ -44,6 +44,7 @@ class AvailabilityContext::DomainInfo final {
   bool isUnavailable() const { return range.isKnownUnreachable(); }
 
   bool constrainRange(const AvailabilityRange &range);
+  bool unionRange(const AvailabilityRange &range);
 
   void Profile(llvm::FoldingSetNodeID &ID) const {
     ID.AddPointer(domain.getOpaqueValue());

lib/AST/AvailabilityContext.cpp

@@ -46,6 +46,15 @@ static bool constrainRange(AvailabilityRange &existing,
   return true;
 }
 
+static bool unionRange(AvailabilityRange &existing,
+                       const AvailabilityRange &other) {
+  if (!existing.isContainedIn(other))
+    return false;
+
+  existing = other;
+  return true;
+}
+
 /// Returns true if `domainInfos` will be constrained by merging the domain
 /// availability represented by `otherDomainInfo`. Additionally, this function
 /// has a couple of side-effects:
@@ -136,6 +145,11 @@ bool AvailabilityContext::DomainInfo::constrainRange(
   return ::constrainRange(range, otherRange);
 }
 
+bool AvailabilityContext::DomainInfo::unionRange(
+    const AvailabilityRange &otherRange) {
+  return ::unionRange(range, otherRange);
+}
+
 AvailabilityContext
 AvailabilityContext::forPlatformRange(const AvailabilityRange &range,
                                       const ASTContext &ctx) {
@@ -284,9 +298,22 @@ void AvailabilityContext::constrainWithPlatformRange(
                          storage->getDomainInfos(), ctx);
 }
 
+void AvailabilityContext::unionWithPlatformRange(const AvailabilityRange &range,
+                                                 const ASTContext &ctx) {
+  auto platformRange = storage->platformRange;
+  if (!unionRange(platformRange, range))
+    return;
+
+  // FIXME: [availability] Should this remove any unavailable platform domains?
+
+  storage = Storage::get(platformRange, storage->isDeprecated,
+                         storage->getDomainInfos(), ctx);
+}
+
 void AvailabilityContext::constrainWithAvailabilityRange(
     const AvailabilityRange &range, AvailabilityDomain domain,
     const ASTContext &ctx) {
+  DEBUG_ASSERT(domain.supportsContextRefinement());
 
   if (domain.isActive(ctx) && domain.isPlatform()) {
     constrainWithPlatformRange(range, ctx);

lib/AST/AvailabilityScopeBuilder.cpp

@@ -103,6 +103,13 @@ class AvailabilityScopeBuilder : private ASTWalker {
     return availability;
   }
 
+  const AvailabilityContext constrainCurrentAvailabilityWithContext(
+      const AvailabilityContext &otherContext) {
+    auto availability = getCurrentScope()->getAvailabilityContext();
+    availability.constrainWithContext(otherContext, Context);
+    return availability;
+  }
+
   void pushContext(AvailabilityScope *scope, ParentTy popAfterNode) {
     ContextInfo info;
     info.Scope = scope;
@@ -701,16 +708,16 @@ class AvailabilityScopeBuilder : private ASTWalker {
   /// There is no need for the caller to explicitly traverse the children
   /// of this node.
   void buildIfStmtRefinementContext(IfStmt *ifStmt) {
-    std::optional<AvailabilityRange> thenRange;
-    std::optional<AvailabilityRange> elseRange;
-    std::tie(thenRange, elseRange) =
+    std::optional<AvailabilityContext> thenContext;
+    std::optional<AvailabilityContext> elseContext;
+    std::tie(thenContext, elseContext) =
         buildStmtConditionRefinementContext(ifStmt->getCond());
 
-    if (thenRange.has_value()) {
+    if (thenContext.has_value()) {
       // Create a new context for the Then branch and traverse it in that new
       // context.
       auto availabilityContext =
-          constrainCurrentAvailabilityWithPlatformRange(thenRange.value());
+          constrainCurrentAvailabilityWithContext(*thenContext);
       auto *thenScope = AvailabilityScope::createForIfStmtThen(
           Context, ifStmt, getCurrentDeclContext(), getCurrentScope(),
           availabilityContext);
@@ -730,11 +737,11 @@ class AvailabilityScopeBuilder : private ASTWalker {
     // the current platform and minimum deployment target.
     // If we add a more precise version range lattice (i.e., one that can
     // support "<") we should create non-empty contexts for the Else branch.
-    if (elseRange.has_value()) {
+    if (elseContext.has_value()) {
       // Create a new context for the Then branch and traverse it in that new
       // context.
       auto availabilityContext =
-          constrainCurrentAvailabilityWithPlatformRange(elseRange.value());
+          constrainCurrentAvailabilityWithContext(*elseContext);
       auto *elseScope = AvailabilityScope::createForIfStmtElse(
           Context, ifStmt, getCurrentDeclContext(), getCurrentScope(),
           availabilityContext);
@@ -749,14 +756,14 @@ class AvailabilityScopeBuilder : private ASTWalker {
   /// There is no need for the caller to explicitly traverse the children
   /// of this node.
   void buildWhileStmtRefinementContext(WhileStmt *whileStmt) {
-    std::optional<AvailabilityRange> bodyRange =
+    std::optional<AvailabilityContext> bodyContext =
         buildStmtConditionRefinementContext(whileStmt->getCond()).first;
 
-    if (bodyRange.has_value()) {
+    if (bodyContext.has_value()) {
       // Create a new context for the body and traverse it in the new
       // context.
       auto availabilityContext =
-          constrainCurrentAvailabilityWithPlatformRange(bodyRange.value());
+          constrainCurrentAvailabilityWithContext(*bodyContext);
       auto *bodyScope = AvailabilityScope::createForWhileStmtBody(
           Context, whileStmt, getCurrentDeclContext(), getCurrentScope(),
           availabilityContext);
@@ -783,15 +790,15 @@ class AvailabilityScopeBuilder : private ASTWalker {
     // This is slightly tricky because, unlike our other control constructs,
     // the refined region is not lexically contained inside the construct
     // introducing the availability scope.
-    std::optional<AvailabilityRange> fallthroughRange;
-    std::optional<AvailabilityRange> elseRange;
-    std::tie(fallthroughRange, elseRange) =
+    std::optional<AvailabilityContext> fallthroughContext;
+    std::optional<AvailabilityContext> elseContext;
+    std::tie(fallthroughContext, elseContext) =
         buildStmtConditionRefinementContext(guardStmt->getCond());
 
     if (Stmt *elseBody = guardStmt->getBody()) {
-      if (elseRange.has_value()) {
+      if (elseContext.has_value()) {
         auto availabilityContext =
-            constrainCurrentAvailabilityWithPlatformRange(elseRange.value());
+            constrainCurrentAvailabilityWithContext(*elseContext);
         auto *trueScope = AvailabilityScope::createForGuardStmtElse(
             Context, guardStmt, getCurrentDeclContext(), getCurrentScope(),
             availabilityContext);
@@ -804,12 +811,12 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
     auto *parentBrace = dyn_cast<BraceStmt>(Parent.getAsStmt());
     assert(parentBrace && "Expected parent of GuardStmt to be BraceStmt");
-    if (!fallthroughRange.has_value())
+    if (!fallthroughContext.has_value())
       return;
 
     // Create a new context for the fallthrough.
     auto fallthroughAvailability =
-        constrainCurrentAvailabilityWithPlatformRange(fallthroughRange.value());
+        constrainCurrentAvailabilityWithContext(*fallthroughContext);
     auto *fallthroughScope = AvailabilityScope::createForGuardStmtFallthrough(
         Context, guardStmt, parentBrace, getCurrentDeclContext(),
         getCurrentScope(), fallthroughAvailability);
@@ -818,10 +825,11 @@ class AvailabilityScopeBuilder : private ASTWalker {
   }
 
   /// Build the availability scopes for a StmtCondition and return a pair of
-  /// optional version ranges, the first for the true branch and the second
-  /// for the false branch. A value of `nullopt` for a given branch indicates
-  /// that the branch does not introduce a new scope.
-  std::pair<std::optional<AvailabilityRange>, std::optional<AvailabilityRange>>
+  /// optional availability contexts, the first for the true branch and the
+  /// second for the false branch. A value of `nullopt` for a given branch
+  /// indicates that the branch does not introduce a new scope.
+  std::pair<std::optional<AvailabilityContext>,
+            std::optional<AvailabilityContext>>
   buildStmtConditionRefinementContext(StmtCondition cond) {
     if (Context.LangOpts.DisableAvailabilityChecking)
       return {};
@@ -835,8 +843,14 @@ class AvailabilityScopeBuilder : private ASTWalker {
     // for the StmtCondition.
     unsigned nestedCount = 0;
 
-    // Tracks the potential version range when the condition is false.
-    auto falseFlow = AvailabilityRange::neverAvailable();
+    // Tracks the availability of the region in which the condition is false.
+    // By default, we assume the false flow is unreachable and therefore start
+    // with no platform versions available in the context. If we find that it
+    // is actually reachable, the context must expand to cover the potentially
+    // available range.
+    auto falseFlowContext = getCurrentScope()->getAvailabilityContext();
+    falseFlowContext.constrainWithPlatformRange(
+        AvailabilityRange::neverAvailable(), Context);
 
     AvailabilityScope *startingScope = getCurrentScope();
 
@@ -845,7 +859,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
     for (StmtConditionElement element : cond) {
       auto *currentScope = getCurrentScope();
-      auto currentInfo = currentScope->getPlatformAvailabilityRange();
+      auto currentContext = currentScope->getAvailabilityContext();
 
       // If the element is not a condition, walk it in the current scope.
       if (element.getKind() != StmtConditionElement::CK_Availability) {
@@ -854,7 +868,9 @@ class AvailabilityScopeBuilder : private ASTWalker {
         // potentially be false, so conservatively combine the version
         // range of the current context with the accumulated false flow
         // of all other conjuncts.
-        falseFlow.unionWith(currentInfo);
+        // FIXME: [availability] Fully union with current context.
+        falseFlowContext.unionWithPlatformRange(
+            currentContext.getPlatformRange(), Context);
 
         element.walk(*this);
         continue;
@@ -956,7 +972,9 @@ class AvailabilityScopeBuilder : private ASTWalker {
         }
       }
 
-      if (currentInfo.isContainedIn(newConstraint)) {
+      auto newContext = currentContext;
+      newContext.constrainWithPlatformRange(newConstraint, Context);
+      if (currentContext.isContainedIn(newContext)) {
         // No need to actually create the availability scope if we know it is
         // useless.
         continue;
@@ -967,38 +985,38 @@ class AvailabilityScopeBuilder : private ASTWalker {
       // context.
       // We could be more precise here if we enriched the lattice to include
       // ranges of the form [x, y).
-      falseFlow.unionWith(currentInfo);
+      // FIXME: [availability] Fully union with current context.
+      falseFlowContext.unionWithPlatformRange(currentContext.getPlatformRange(),
+                                              Context);
 
-      auto constrainedAvailability =
-          constrainCurrentAvailabilityWithPlatformRange(newConstraint);
       auto *scope = AvailabilityScope::createForConditionFollowingQuery(
           Context, query, lastElement, getCurrentDeclContext(), currentScope,
-          constrainedAvailability);
+          newContext);
 
       pushContext(scope, ParentTy());
       ++nestedCount;
     }
 
-    std::optional<AvailabilityRange> falseRefinement = std::nullopt;
+    std::optional<AvailabilityContext> falseRefinement = std::nullopt;
     // The version range for the false branch should never have any versions
     // that weren't possible when the condition started evaluating.
-    assert(
-        falseFlow.isContainedIn(startingScope->getPlatformAvailabilityRange()));
+    assert(falseFlowContext.isContainedIn(
+        startingScope->getAvailabilityContext()));
 
-    // If the starting version range is not completely contained in the
-    // false flow version range then it must be the case that false flow range
-    // is strictly smaller than the starting range (because the false flow
-    // range *is* contained in the starting range), so we should introduce a
+    // If the starting availability context is not completely contained in the
+    // false flow context then it must be the case that false flow context
+    // is strictly smaller than the starting context (because the false flow
+    // context *is* contained in the starting context), so we should introduce a
     // new availability scope for the false flow.
-    if (!startingScope->getPlatformAvailabilityRange().isContainedIn(
-            falseFlow)) {
-      falseRefinement = falseFlow;
+    if (!startingScope->getAvailabilityContext().isContainedIn(
+            falseFlowContext)) {
+      falseRefinement = falseFlowContext;
     }
 
     auto makeResult =
-        [isUnavailability](std::optional<AvailabilityRange> trueRefinement,
-                           std::optional<AvailabilityRange> falseRefinement) {
-          if (isUnavailability.has_value() && isUnavailability.value()) {
+        [isUnavailability](std::optional<AvailabilityContext> trueRefinement,
+                           std::optional<AvailabilityContext> falseRefinement) {
+          if (isUnavailability.has_value() && *isUnavailability) {
             // If this is an unavailability check, invert the result.
             return std::make_pair(falseRefinement, trueRefinement);
           }
@@ -1014,8 +1032,7 @@ class AvailabilityScopeBuilder : private ASTWalker {
 
     assert(getCurrentScope() == startingScope);
 
-    return makeResult(nestedScope->getPlatformAvailabilityRange(),
-                      falseRefinement);
+    return makeResult(nestedScope->getAvailabilityContext(), falseRefinement);
   }
 
   /// Return the best active spec for the target platform or nullptr if no

test/Sema/availability_scopes.swift

@@ -94,6 +94,7 @@ extension SomeClass {
 // CHECK-NEXT: {{^}}          (condition_following_availability version=56
 // CHECK-NEXT: {{^}}          (guard_fallthrough version=56
 // CHECK-NEXT: {{^}}      (decl version=57 decl=funcInInnerIfElse()
+// CHECK-NEXT: {{^}}    (decl version=53 decl=funcInOuterIfElse()
 @available(OSX 51, *)
 func functionWithStmtCondition() {
   if #available(OSX 52, *),
@@ -109,6 +110,9 @@ func functionWithStmtCondition() {
       @available(OSX 57, *)
       func funcInInnerIfElse() { }
     }
+  } else {
+    @available(OSX 53, *)
+    func funcInOuterIfElse() { }
   }
 }
 
@@ -247,6 +251,45 @@ extension SomeClass {
   }()
 }
 
+// CHECK-NEXT: {{^}}  (decl_implicit version=50 decl=extension.SomeClass
+// CHECK-NEXT: {{^}}    (decl version=50 unavailable=macOS decl=extension.SomeClass
+// CHECK-NEXT: {{^}}      (decl version=51 unavailable=macOS decl=functionWithStmtConditionsInUnavailableExt()
+// CHECK-NEXT: {{^}}        (condition_following_availability version=52 unavailable=macOS
+// CHECK-NEXT: {{^}}          (condition_following_availability version=53 unavailable=macOS
+// CHECK-NEXT: {{^}}        (if_then version=53 unavailable=macOS
+// CHECK-NEXT: {{^}}          (condition_following_availability version=54 unavailable=macOS
+// CHECK-NEXT: {{^}}          (if_then version=54 unavailable=macOS
+// CHECK-NEXT: {{^}}            (condition_following_availability version=55 unavailable=macOS
+// CHECK-NEXT: {{^}}            (decl version=55 unavailable=macOS decl=funcInGuardElse()
+// CHECK-NEXT: {{^}}            (guard_fallthrough version=55 unavailable=macOS
+// CHECK-NEXT: {{^}}              (condition_following_availability version=56 unavailable=macOS
+// CHECK-NEXT: {{^}}              (guard_fallthrough version=56 unavailable=macOS
+// CHECK-NEXT: {{^}}          (decl version=57 unavailable=macOS decl=funcInInnerIfElse()
+// CHECK-NEXT: {{^}}        (decl version=53 unavailable=macOS decl=funcInOuterIfElse()
+@available(OSX, unavailable)
+extension SomeClass {
+  @available(OSX 51, *)
+  func functionWithStmtConditionsInUnavailableExt() {
+    if #available(OSX 52, *),
+       let x = (nil as Int?),
+       #available(OSX 53, *) {
+      if #available(OSX 54, *) {
+        guard #available(OSX 55, *) else {
+          @available(OSX 55, *)
+          func funcInGuardElse() { }
+        }
+        guard #available(OSX 56, *) else { }
+      } else {
+        @available(OSX 57, *)
+        func funcInInnerIfElse() { }
+      }
+    } else {
+      @available(OSX 53, *)
+      func funcInOuterIfElse() { }
+    }
+  }
+}
+
 // CHECK-NEXT: {{^}}  (decl_implicit version=50 decl=wrappedValue
 
 @propertyWrapper