Serialization: Serialize PackConformance

Author: slavapestov

lib/Serialization/DeclTypeRecordNodes.def

@@ -190,7 +190,7 @@ OTHER(EXPANDED_MACRO_REPLACEMENTS, 132)
 OTHER(NORMAL_PROTOCOL_CONFORMANCE, 141)
 OTHER(SPECIALIZED_PROTOCOL_CONFORMANCE, 142)
 OTHER(INHERITED_PROTOCOL_CONFORMANCE, 143)
-// 144 is unused; was INVALID_PROTOCOL_CONFORMANCE
+OTHER(PACK_CONFORMANCE, 144)
 
 OTHER(SIL_LAYOUT, 145)
 // 146 is unused; was NORMAL_PROTOCOL_CONFORMANCE_ID

lib/Serialization/Deserialization.cpp

@@ -26,6 +26,7 @@
 #include "swift/AST/Initializer.h"
 #include "swift/AST/MacroDefinition.h"
 #include "swift/AST/NameLookupRequests.h"
+#include "swift/AST/PackConformance.h"
 #include "swift/AST/ParameterList.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/PrettyStackTrace.h"
@@ -498,6 +499,9 @@ class ProtocolConformanceDeserializer {
                     ModuleFile::Serialized<ProtocolConformance *> &entry);
   Expected<ProtocolConformance *>
   readNormalProtocolConformanceXRef(ArrayRef<uint64_t> data);
+
+  Expected<PackConformance *>
+  read(ModuleFile::Serialized<PackConformance *> &entry);
 };
 } // end namespace swift
 
@@ -761,6 +765,65 @@ ProtocolConformanceDeserializer::readNormalProtocolConformance(
   return conformance;
 }
 
+Expected<PackConformance*>
+ProtocolConformanceDeserializer::read(
+          ModuleFile::Serialized<PackConformance *> &conformanceEntry) {
+  using namespace decls_block;
+
+  SmallVector<uint64_t, 16> scratch;
+
+  llvm::BitstreamEntry entry =
+      MF.fatalIfUnexpected(MF.DeclTypeCursor.advance());
+
+  if (entry.Kind != llvm::BitstreamEntry::Record) {
+    // We don't know how to serialize types represented by sub-blocks.
+    return MF.diagnoseFatal();
+  }
+
+  StringRef blobData;
+  unsigned kind = MF.fatalIfUnexpected(
+      MF.DeclTypeCursor.readRecord(entry.ID, scratch, &blobData));
+  assert(blobData.empty());
+
+  if (kind != decls_block::PACK_CONFORMANCE)
+    return MF.diagnoseFatal(llvm::make_error<InvalidRecordKindError>(kind));
+
+  TypeID patternTypeID;
+  DeclID protocolID;
+  ArrayRef<uint64_t> patternConformanceIDs;
+  PackConformanceLayout::readRecord(scratch,
+                                    patternTypeID, protocolID,
+                                    patternConformanceIDs);
+
+  auto patternTypeOrError = MF.getTypeChecked(patternTypeID);
+  if (!patternTypeOrError)
+    return patternTypeOrError.takeError();
+  auto patternType = patternTypeOrError.get();
+
+  auto protocolOrError = MF.getDeclChecked(protocolID);
+  if (!protocolOrError)
+    return protocolOrError.takeError();
+  auto *protocol = protocolOrError.get();
+
+  PrettyStackTraceType trace(MF.getAssociatedModule()->getASTContext(),
+                             "reading pack conformance for",
+                             patternType);
+
+  SmallVector<ProtocolConformanceRef, 4> patternConformances;
+  for (auto confID : patternConformanceIDs) {
+    auto confOrError = MF.getConformanceChecked(confID);
+    if (!confOrError)
+      return confOrError.takeError();
+    patternConformances.push_back(confOrError.get());
+  }
+
+  auto conformance =
+         PackConformance::get(patternType->castTo<PackType>(),
+                              cast<ProtocolDecl>(protocol),
+                              patternConformances);
+  return conformance;
+}
+
 ProtocolConformanceRef
 ModuleFile::getConformance(ProtocolConformanceID id,
                            GenericEnvironment *genericEnv) {
@@ -777,42 +840,68 @@ ModuleFile::getConformanceChecked(ProtocolConformanceID conformanceID,
 
   if (conformanceID == 0) return ProtocolConformanceRef::forInvalid();
 
-  // If the low bit is sit, this is an abstract conformance.
-  if ((conformanceID & 1) == 0) {
-    auto protocolID = conformanceID >> 1;
+  switch (conformanceID & SerializedProtocolConformanceKind::Mask) {
+  case SerializedProtocolConformanceKind::Abstract: {
+    auto protocolID = conformanceID >> SerializedProtocolConformanceKind::Shift;
     auto maybeProtocol = getDeclChecked(protocolID);
     if (!maybeProtocol)
       return maybeProtocol.takeError();
     auto proto = cast<ProtocolDecl>(maybeProtocol.get());
     return ProtocolConformanceRef(proto);
   }
 
-  // Otherwise, it's a concrete conformance.
-  auto conformanceIndex = (conformanceID >> 1) - 1;
-  assert(conformanceIndex < Conformances.size() && "invalid conformance ID");
-  auto &conformanceOrOffset = Conformances[conformanceIndex];
-  if (!conformanceOrOffset.isComplete()) {
-    BCOffsetRAII restoreOffset(DeclTypeCursor);
-    if (auto error = diagnoseFatalIfNotSuccess(
-            DeclTypeCursor.JumpToBit(conformanceOrOffset)))
-      return std::move(error);
-
-    auto result =
-      ProtocolConformanceDeserializer(*this).read(conformanceOrOffset);
-    if (!result)
-      return result.takeError();
-
-    conformanceOrOffset = result.get();
-  }
-  auto conformance = conformanceOrOffset.get();
-  if (!genericEnv || !conformance->getType()->hasTypeParameter())
+  case SerializedProtocolConformanceKind::Concrete: {
+    auto conformanceIndex = (conformanceID >> SerializedProtocolConformanceKind::Shift) - 1;
+    assert(conformanceIndex < Conformances.size() && "invalid conformance ID");
+    auto &conformanceOrOffset = Conformances[conformanceIndex];
+    if (!conformanceOrOffset.isComplete()) {
+      BCOffsetRAII restoreOffset(DeclTypeCursor);
+      if (auto error = diagnoseFatalIfNotSuccess(
+              DeclTypeCursor.JumpToBit(conformanceOrOffset)))
+        return std::move(error);
+
+      auto result =
+        ProtocolConformanceDeserializer(*this).read(conformanceOrOffset);
+      if (!result)
+        return result.takeError();
+
+      conformanceOrOffset = result.get();
+    }
+    auto conformance = conformanceOrOffset.get();
+    if (!genericEnv || !conformance->getType()->hasTypeParameter())
+      return ProtocolConformanceRef(conformance);
+
+    // If we have a generic environment, map the conformance into context.
+    auto mappedConformance =
+      genericEnv->mapConformanceRefIntoContext(conformance->getType(),
+                                       ProtocolConformanceRef(conformance));
+    return mappedConformance.second;
+  }
+
+  case SerializedProtocolConformanceKind::Pack: {
+    auto conformanceIndex = (conformanceID >> SerializedProtocolConformanceKind::Shift) - 1;
+    assert(conformanceIndex < Conformances.size() && "invalid pack conformance ID");
+    auto &conformanceOrOffset = Conformances[conformanceIndex];
+    if (!conformanceOrOffset.isComplete()) {
+      BCOffsetRAII restoreOffset(DeclTypeCursor);
+      if (auto error = diagnoseFatalIfNotSuccess(
+              DeclTypeCursor.JumpToBit(conformanceOrOffset)))
+        return std::move(error);
+
+      auto result =
+        ProtocolConformanceDeserializer(*this).read(conformanceOrOffset);
+      if (!result)
+        return result.takeError();
+
+      conformanceOrOffset = result.get();
+    }
+    auto conformance = conformanceOrOffset.get();
     return ProtocolConformanceRef(conformance);
+  }
 
-  // If we have a generic environment, map the conformance into context.
-  auto mappedConformance =
-    genericEnv->mapConformanceRefIntoContext(conformance->getType(),
-                                     ProtocolConformanceRef(conformance));
-  return mappedConformance.second;
+  default:
+    llvm_unreachable("Invalid conformance");
+  }
 }
 
 GenericParamList *ModuleFile::maybeReadGenericParams(DeclContext *DC) {

lib/Serialization/ModuleFile.h

@@ -254,6 +254,9 @@ class ModuleFile
   /// Protocol conformances referenced by this module.
   MutableArrayRef<Serialized<ProtocolConformance *>> Conformances;
 
+  /// Pack conformances referenced by this module.
+  MutableArrayRef<Serialized<PackConformance *>> PackConformances;
+
   /// SILLayouts referenced by this module.
   MutableArrayRef<Serialized<SILLayout *>> SILLayouts;
 

lib/Serialization/ModuleFileSharedCore.cpp

@@ -890,6 +890,10 @@ bool ModuleFileSharedCore::readIndexBlock(llvm::BitstreamCursor &cursor) {
         assert(blobData.empty());
         allocateBuffer(Conformances, scratch);
         break;
+      case index_block::PACK_CONFORMANCE_OFFSETS:
+        assert(blobData.empty());
+        allocateBuffer(PackConformances, scratch);
+        break;
       case index_block::SIL_LAYOUT_OFFSETS:
         assert(blobData.empty());
         allocateBuffer(SILLayouts, scratch);

lib/Serialization/ModuleFileSharedCore.h

@@ -229,6 +229,9 @@ class ModuleFileSharedCore {
   /// Protocol conformances referenced by this module.
   ArrayRef<RawBitOffset> Conformances;
 
+  /// Pack conformances referenced by this module.
+  ArrayRef<RawBitOffset> PackConformances;
+
   /// SILLayouts referenced by this module.
   ArrayRef<RawBitOffset> SILLayouts;
 

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 = 759; // change PackType
+const uint16_t SWIFTMODULE_VERSION_MINOR = 780; // serialize PackConformance
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -140,6 +140,21 @@ class DeclContextIDField : public BCFixed<32> {
 using ProtocolConformanceID = DeclID;
 using ProtocolConformanceIDField = DeclIDField;
 
+// The low two bits of the ProtocolConformanceID determine the kind:
+// 00 -- abstract conformance
+// 01 -- concrete conformance
+// 10 -- pack conformance
+struct SerializedProtocolConformanceKind {
+  enum  {
+    Abstract = 0,
+    Concrete = 1,
+    Pack = 2,
+
+    Shift = 2,
+    Mask = 3
+  };
+};
+
 // GenericSignatureID must be the same as DeclID because it is stored in the
 // same way.
 using GenericSignatureID = DeclID;
@@ -1910,6 +1925,13 @@ namespace decls_block {
     BCArray<BCVBR<6>> // conditional requirements
   >;
 
+  using PackConformanceLayout = BCRecordLayout<
+    PACK_CONFORMANCE,
+    TypeIDField,                         // pattern type
+    DeclIDField,                         // the protocol
+    BCArray<ProtocolConformanceIDField>  // pattern conformances
+  >;
+
   using ProtocolConformanceXrefLayout = BCRecordLayout<
     PROTOCOL_CONFORMANCE_XREF,
     DeclIDField, // the protocol being conformed to
@@ -2344,6 +2366,7 @@ namespace index_block {
     GENERIC_SIGNATURE_OFFSETS,
     GENERIC_ENVIRONMENT_OFFSETS,
     PROTOCOL_CONFORMANCE_OFFSETS,
+    PACK_CONFORMANCE_OFFSETS,
     SIL_LAYOUT_OFFSETS,
 
     PRECEDENCE_GROUPS,