[Serialization] Add a "unavailable" bit to conditional substitution record

A step towards supporting different opaque result type produced by a
`if #unavailable` block.

Author: xedin

lib/Serialization/DeclTypeRecordNodes.def

@@ -199,6 +199,7 @@ OTHER(DERIVATIVE_FUNCTION_CONFIGURATION, 154)
 OTHER(ERROR_FLAG, 155)
 
 TRAILING_INFO(CONDITIONAL_SUBSTITUTION)
+TRAILING_INFO(CONDITIONAL_SUBSTITUTION_COND)
 
 #ifndef DECL_ATTR
 #define DECL_ATTR(NAME, CLASS, OPTIONS, CODE) RECORD_VAL(CLASS##_DECL_ATTR, 180+CODE)

lib/Serialization/Deserialization.cpp

@@ -3548,6 +3548,39 @@ class DeclDeserializer {
     return deserializeAnyFunc(scratch, blobData, /*isAccessor*/true);
   }
 
+  void deserializeConditionalSubstitutionConditions(
+      SmallVectorImpl<VersionRange> &conditions) {
+    using namespace decls_block;
+
+    SmallVector<uint64_t, 4> scratch;
+    StringRef blobData;
+
+    while (true) {
+      llvm::BitstreamEntry entry =
+          MF.fatalIfUnexpected(MF.DeclTypeCursor.advance(AF_DontPopBlockAtEnd));
+      if (entry.Kind != llvm::BitstreamEntry::Record)
+        break;
+
+      scratch.clear();
+
+      unsigned recordID = MF.fatalIfUnexpected(
+          MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
+      if (recordID != decls_block::CONDITIONAL_SUBSTITUTION_COND)
+        break;
+
+      bool isUnavailability;
+      DEF_VER_TUPLE_PIECES(condition);
+
+      ConditionalSubstitutionConditionLayout::readRecord(
+          scratch, isUnavailability, LIST_VER_TUPLE_PIECES(condition));
+
+      llvm::VersionTuple condition;
+      DECODE_VER_TUPLE(condition);
+
+      conditions.push_back(VersionRange::allGTE(condition));
+    }
+  }
+
   void deserializeConditionalSubstitutions(
       SmallVectorImpl<OpaqueTypeDecl::ConditionallyAvailableSubstitutions *>
           &limitedAvailability) {
@@ -3566,20 +3599,16 @@ class DeclDeserializer {
       if (recordID != decls_block::CONDITIONAL_SUBSTITUTION)
         break;
 
-      ArrayRef<uint64_t> rawConditions;
       SubstitutionMapID substitutionMapRef;
 
       decls_block::ConditionalSubstitutionLayout::readRecord(
-          scratch, substitutionMapRef, rawConditions);
-
-      SmallVector<VersionRange, 4> conditions;
-      llvm::transform(rawConditions, std::back_inserter(conditions),
-                      [&](uint64_t id) {
-                        llvm::VersionTuple lowerEndpoint;
-                        if (lowerEndpoint.tryParse(MF.getIdentifier(id).str()))
-                          MF.fatal();
-                        return VersionRange::allGTE(lowerEndpoint);
-                      });
+          scratch, substitutionMapRef);
+
+      SmallVector<VersionRange, 2> conditions;
+      deserializeConditionalSubstitutionConditions(conditions);
+
+      if (conditions.empty())
+        MF.fatal();
 
       auto subMapOrError = MF.getSubstitutionMapChecked(substitutionMapRef);
       if (!subMapOrError)

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 697; // change local type mangling
+const uint16_t SWIFTMODULE_VERSION_MINOR = 698; // opaque decl with unavailability conditions
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1462,10 +1462,17 @@ namespace decls_block {
     // - inlinable body text, if any
   >;
 
+  using ConditionalSubstitutionConditionLayout = BCRecordLayout<
+    CONDITIONAL_SUBSTITUTION_COND,
+    BCFixed<1>, // is unavailable?
+    BC_AVAIL_TUPLE // the OS version triple.
+  >;
+
   using ConditionalSubstitutionLayout = BCRecordLayout<
     CONDITIONAL_SUBSTITUTION,
-    SubstitutionMapIDField,
-    BCArray<IdentifierIDField> // N conditions where each is <major>.<minor>.<patch>
+    SubstitutionMapIDField
+    // Trailed by N conditions that include a version and
+    // unavailability indicator.
   >;
 
   using OpaqueTypeLayout = BCRecordLayout<

lib/Serialization/Serialization.cpp

@@ -3945,17 +3945,19 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
           S.DeclTypeAbbrCodes[ConditionalSubstitutionLayout::Code];
       for (const auto *subs :
            opaqueDecl->getConditionallyAvailableSubstitutions().drop_back()) {
-        SmallVector<IdentifierID, 4> conditions;
+        ConditionalSubstitutionLayout::emitRecord(
+            S.Out, S.ScratchRecord, abbrCode,
+            S.addSubstitutionMapRef(subs->getSubstitutions()));
 
+        unsigned condAbbrCode =
+            S.DeclTypeAbbrCodes[ConditionalSubstitutionConditionLayout::Code];
         for (const auto &condition : subs->getAvailability()) {
-          auto lowerEndpoint = condition.getLowerEndpoint();
-          conditions.push_back(
-              S.addUniquedStringRef(lowerEndpoint.getAsString()));
+          ENCODE_VER_TUPLE(osVersion, llvm::Optional<llvm::VersionTuple>(
+                                          condition.getLowerEndpoint()));
+          ConditionalSubstitutionConditionLayout::emitRecord(
+              S.Out, S.ScratchRecord, condAbbrCode, /*isUnavailable=*/false,
+              LIST_VER_TUPLE_PIECES(osVersion));
         }
-
-        ConditionalSubstitutionLayout::emitRecord(
-            S.Out, S.ScratchRecord, abbrCode,
-            S.addSubstitutionMapRef(subs->getSubstitutions()), conditions);
       }
     }
   }
@@ -5134,6 +5136,7 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<XRefLayout>();
 
   registerDeclTypeAbbr<ConditionalSubstitutionLayout>();
+  registerDeclTypeAbbr<ConditionalSubstitutionConditionLayout>();
 
 #define DECL_ATTR(X, NAME, ...) \
   registerDeclTypeAbbr<NAME##DeclAttrLayout>();