[Decl] Start storing and serializing "unavailability" bit per condition

Author: xedin

include/swift/AST/Decl.h

@@ -2952,9 +2952,12 @@ class OpaqueTypeDecl final :
     return false;
   }
 
+  using AvailabilityCondition = std::pair<VersionRange, bool>;
+
   class ConditionallyAvailableSubstitutions final
-      : private llvm::TrailingObjects<ConditionallyAvailableSubstitutions,
-                                      VersionRange> {
+      : private llvm::TrailingObjects<
+            ConditionallyAvailableSubstitutions,
+            AvailabilityCondition> {
     friend TrailingObjects;
 
     unsigned NumAvailabilityConditions;
@@ -2964,25 +2967,25 @@ class OpaqueTypeDecl final :
     /// A type with limited availability described by the provided set
     /// of availability conditions (with `and` relationship).
     ConditionallyAvailableSubstitutions(
-        ArrayRef<VersionRange> availabilityContext,
+        ArrayRef<AvailabilityCondition> availabilityContext,
         SubstitutionMap substitutions)
         : NumAvailabilityConditions(availabilityContext.size()),
           Substitutions(substitutions) {
       assert(!availabilityContext.empty());
       std::uninitialized_copy(availabilityContext.begin(),
                               availabilityContext.end(),
-                              getTrailingObjects<VersionRange>());
+                              getTrailingObjects<AvailabilityCondition>());
     }
 
   public:
-    ArrayRef<VersionRange> getAvailability() const {
-      return {getTrailingObjects<VersionRange>(), NumAvailabilityConditions};
+    ArrayRef<AvailabilityCondition> getAvailability() const {
+      return {getTrailingObjects<AvailabilityCondition>(), NumAvailabilityConditions};
     }
 
     SubstitutionMap getSubstitutions() const { return Substitutions; }
 
     static ConditionallyAvailableSubstitutions *
-    get(ASTContext &ctx, ArrayRef<VersionRange> availabilityContext,
+    get(ASTContext &ctx, ArrayRef<AvailabilityCondition> availabilityContext,
         SubstitutionMap substitutions);
   };
 };

lib/AST/Decl.cpp

@@ -8263,9 +8263,11 @@ void OpaqueTypeDecl::setConditionallyAvailableSubstitutions(
 
 OpaqueTypeDecl::ConditionallyAvailableSubstitutions *
 OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-    ASTContext &ctx, ArrayRef<VersionRange> availabilityContext,
+    ASTContext &ctx,
+    ArrayRef<AvailabilityCondition> availabilityContext,
     SubstitutionMap substitutions) {
-  auto size = totalSizeToAlloc<VersionRange>(availabilityContext.size());
+  auto size =
+      totalSizeToAlloc<AvailabilityCondition>(availabilityContext.size());
   auto mem = ctx.Allocate(size, alignof(ConditionallyAvailableSubstitutions));
   return new (mem)
       ConditionallyAvailableSubstitutions(availabilityContext, substitutions);

lib/IRGen/GenMeta.cpp

@@ -2333,9 +2333,9 @@ namespace {
             for (unsigned condIndex : indices(conditions)) {
               const auto &condition = conditions[condIndex];
 
-              assert(condition.hasLowerEndpoint());
+              assert(condition.first.hasLowerEndpoint());
 
-              auto version = condition.getLowerEndpoint();
+              auto version = condition.first.getLowerEndpoint();
               auto *major = getInt32Constant(version.getMajor());
               auto *minor = getInt32Constant(version.getMinor());
               auto *patch = getInt32Constant(version.getSubminor());
@@ -2367,7 +2367,7 @@ namespace {
           auto universal = substitutionSet.back();
 
           assert(universal->getAvailability().size() == 1 &&
-                 universal->getAvailability()[0].isEmpty());
+                 universal->getAvailability()[0].first.isEmpty());
 
           IGF.Builder.CreateRet(
               getResultValue(IGF, genericEnv, universal->getSubstitutions()));

lib/Sema/MiscDiagnostics.cpp

@@ -2809,6 +2809,8 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
   // There is no clear winner here since there are candidates within
   // limited availability contexts.
   void finalizeOpaque(const Candidate &universallyAvailable) {
+    using AvailabilityCondition = OpaqueTypeDecl::AvailabilityCondition;
+
     SmallVector<OpaqueTypeDecl::ConditionallyAvailableSubstitutions *, 4>
         conditionalSubstitutions;
 
@@ -2819,12 +2821,14 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
       if (!availabilityContext)
         continue;
 
-      SmallVector<VersionRange, 4> conditions;
+      SmallVector<AvailabilityCondition, 4> conditions;
 
       llvm::transform(availabilityContext->getCond(),
                       std::back_inserter(conditions),
                       [&](const StmtConditionElement &elt) {
-                        return elt.getAvailability()->getAvailableRange();
+                        auto condition = elt.getAvailability();
+                        return std::make_pair(condition->getAvailableRange(),
+                                              condition->isUnavailability());
                       });
 
       conditionalSubstitutions.push_back(
@@ -2836,7 +2840,7 @@ class OpaqueUnderlyingTypeChecker : public ASTWalker {
     // Add universally available choice as the last one.
     conditionalSubstitutions.push_back(
         OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-            Ctx, {VersionRange::empty()},
+            Ctx, {{VersionRange::empty(), /*unavailable=*/false}},
             std::get<1>(universallyAvailable)
                 .mapReplacementTypesOutOfContext()));
 

lib/Serialization/Deserialization.cpp

@@ -3549,7 +3549,7 @@ class DeclDeserializer {
   }
 
   void deserializeConditionalSubstitutionConditions(
-      SmallVectorImpl<VersionRange> &conditions) {
+      SmallVectorImpl<OpaqueTypeDecl::AvailabilityCondition> &conditions) {
     using namespace decls_block;
 
     SmallVector<uint64_t, 4> scratch;
@@ -3577,7 +3577,8 @@ class DeclDeserializer {
       llvm::VersionTuple condition;
       DECODE_VER_TUPLE(condition);
 
-      conditions.push_back(VersionRange::allGTE(condition));
+      conditions.push_back(std::make_pair(VersionRange::allGTE(condition),
+                                          isUnavailability));
     }
   }
 
@@ -3604,7 +3605,7 @@ class DeclDeserializer {
       decls_block::ConditionalSubstitutionLayout::readRecord(
           scratch, substitutionMapRef);
 
-      SmallVector<VersionRange, 2> conditions;
+      SmallVector<OpaqueTypeDecl::AvailabilityCondition, 2> conditions;
       deserializeConditionalSubstitutionConditions(conditions);
 
       if (conditions.empty())
@@ -3684,7 +3685,8 @@ class DeclDeserializer {
       } else {
         limitedAvailability.push_back(
             OpaqueTypeDecl::ConditionallyAvailableSubstitutions::get(
-                ctx, VersionRange::empty(), subMapOrError.get()));
+                ctx, {{VersionRange::empty(), /*unavailability=*/false}},
+                subMapOrError.get()));
 
         opaqueDecl->setConditionallyAvailableSubstitutions(limitedAvailability);
       }

lib/Serialization/Serialization.cpp

@@ -3953,9 +3953,10 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
             S.DeclTypeAbbrCodes[ConditionalSubstitutionConditionLayout::Code];
         for (const auto &condition : subs->getAvailability()) {
           ENCODE_VER_TUPLE(osVersion, llvm::Optional<llvm::VersionTuple>(
-                                          condition.getLowerEndpoint()));
+                                          condition.first.getLowerEndpoint()));
           ConditionalSubstitutionConditionLayout::emitRecord(
-              S.Out, S.ScratchRecord, condAbbrCode, /*isUnavailable=*/false,
+              S.Out, S.ScratchRecord, condAbbrCode,
+              /*isUnavailable=*/condition.second,
               LIST_VER_TUPLE_PIECES(osVersion));
         }
       }