[Serialization] Support (de-)serialization of SubstitutionMaps.

Allow substitution maps to be serialized directly (via an ID), writing out
the replacement types and conformances as appropriate. This is a more
efficient form of serialization than the current SubstitutionList approach,
because it maintains uniqueness of substitution maps within a module file,
and is a step toward eliminating SubstitutionList entirely.

Author: DougGregor

include/swift/AST/SubstitutionMap.h

@@ -22,6 +22,7 @@
 #include "swift/AST/SubstitutionList.h"
 #include "swift/AST/Type.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -154,25 +155,10 @@ class SubstitutionMap {
   /// signature nor any replacement types/conformances.
   Storage *storage = nullptr;
 
-  /// Retrieve the array of replacement types, which line up with the
-  /// generic parameters.
-  ///
-  /// Note that the types may be null, for cases where the generic parameter
-  /// is concrete but hasn't been queried yet.
-  ArrayRef<Type> getReplacementTypes() const {
-    return storage ? storage->getReplacementTypes() : ArrayRef<Type>();
-  }
-
   MutableArrayRef<Type> getReplacementTypes() {
     return storage ? storage->getReplacementTypes() : MutableArrayRef<Type>();
   }
 
-  /// Retrieve the array of protocol conformances, which line up with the
-  /// requirements of the generic signature.
-  ArrayRef<ProtocolConformanceRef> getConformances() const {
-    return storage ? storage->getConformances()
-                   : ArrayRef<ProtocolConformanceRef>();
-  }
   MutableArrayRef<ProtocolConformanceRef> getConformances() {
     return storage ? storage->getConformances()
                    : MutableArrayRef<ProtocolConformanceRef>();
@@ -185,10 +171,21 @@ class SubstitutionMap {
                   ArrayRef<ProtocolConformanceRef> conformances)
     : storage(Storage::get(genericSig, replacementTypes, conformances)) { }
 
+  explicit SubstitutionMap(Storage *storage) : storage(storage) { }
+
 public:
   /// Build an empty substitution map.
   SubstitutionMap() { }
 
+  /// Build an interface type substitution map for the given generic
+  /// signature and a vector of Substitutions that correspond to the
+  /// requirements of this generic signature.
+  static SubstitutionMap get(GenericSignature *genericSig,
+                             ArrayRef<Type> replacementTypes,
+                             ArrayRef<ProtocolConformanceRef> conformances) {
+    return SubstitutionMap(genericSig, replacementTypes, conformances);
+  }
+
   /// Build an interface type substitution map for the given generic
   /// signature and a vector of Substitutions that correspond to the
   /// requirements of this generic signature.
@@ -207,13 +204,32 @@ class SubstitutionMap {
     return storage ? storage->getGenericSignature() : nullptr;
   }
 
+  /// Retrieve the array of protocol conformances, which line up with the
+  /// requirements of the generic signature.
+  ArrayRef<ProtocolConformanceRef> getConformances() const {
+    return storage ? storage->getConformances()
+                   : ArrayRef<ProtocolConformanceRef>();
+  }
+
   /// Look up a conformance for the given type to the given protocol.
   Optional<ProtocolConformanceRef>
   lookupConformance(CanType type, ProtocolDecl *proto) const;
 
   /// Whether the substitution map is empty.
   bool empty() const { return getGenericSignature() == nullptr; }
 
+  /// Whether the substitution map is non-empty.
+  explicit operator bool() const { return !empty(); }
+
+  /// Retrieve the array of replacement types, which line up with the
+  /// generic parameters.
+  ///
+  /// Note that the types may be null, for cases where the generic parameter
+  /// is concrete but hasn't been queried yet.
+  ArrayRef<Type> getReplacementTypes() const {
+    return storage ? storage->getReplacementTypes() : ArrayRef<Type>();
+  }
+
   /// Query whether any replacement types in the map contain archetypes.
   bool hasArchetypes() const;
 
@@ -292,6 +308,22 @@ class SubstitutionMap {
   /// Profile the substitution map, for use with LLVM's FoldingSet.
   void profile(llvm::FoldingSetNodeID &id) const;
 
+  const void *getOpaqueValue() const { return storage; }
+
+  static SubstitutionMap getFromOpaqueValue(const void *ptr) {
+    return SubstitutionMap(const_cast<Storage *>((const Storage *)ptr));
+  }
+
+  static SubstitutionMap getEmptyKey() {
+    return SubstitutionMap(
+             (Storage *)llvm::DenseMapInfo<void*>::getEmptyKey());
+  }
+
+  static SubstitutionMap getTombstoneKey() {
+    return SubstitutionMap(
+               (Storage *)llvm::DenseMapInfo<void*>::getTombstoneKey());
+  }
+
 private:
   friend class GenericSignature;
   friend class GenericEnvironment;
@@ -306,4 +338,37 @@ class SubstitutionMap {
 
 } // end namespace swift
 
+namespace llvm {
+  template <>
+  struct PointerLikeTypeTraits<swift::SubstitutionMap> {
+    static void *getAsVoidPointer(swift::SubstitutionMap map) {
+      return const_cast<void *>(map.getOpaqueValue());
+    }
+    static swift::SubstitutionMap getFromVoidPointer(const void *ptr) {
+      return swift::SubstitutionMap::getFromOpaqueValue(ptr);
+    }
+
+    /// Note: Assuming storage is at leaste 4-byte aligned.
+    enum { NumLowBitsAvailable = 2 };
+  };
+
+  // Substitution maps hash just like pointers.
+  template<> struct DenseMapInfo<swift::SubstitutionMap> {
+    static swift::SubstitutionMap getEmptyKey() {
+      return swift::SubstitutionMap::getEmptyKey();
+    }
+    static swift::SubstitutionMap getTombstoneKey() {
+      return swift::SubstitutionMap::getTombstoneKey();
+    }
+    static unsigned getHashValue(swift::SubstitutionMap map) {
+      return DenseMapInfo<void*>::getHashValue(map.getOpaqueValue());
+    }
+    static bool isEqual(swift::SubstitutionMap lhs,
+                        swift::SubstitutionMap rhs) {
+      return lhs.getOpaqueValue() == rhs.getOpaqueValue();
+    }
+  };
+
+}
+
 #endif

include/swift/Serialization/DeclTypeRecordNodes.def

@@ -166,6 +166,7 @@ TRAILING_INFO(GENERIC_REQUIREMENT)
 TRAILING_INFO(LAYOUT_REQUIREMENT)
 OTHER(GENERIC_SIGNATURE, 244)
 OTHER(SIL_GENERIC_ENVIRONMENT, 245)
+OTHER(SUBSTITUTION_MAP, 246)
 
 OTHER(LOCAL_DISCRIMINATOR, 248)
 OTHER(PRIVATE_DISCRIMINATOR, 249)

include/swift/Serialization/ModuleFile.h

@@ -310,6 +310,9 @@ class ModuleFile
   /// Generic environments referenced by this module.
   std::vector<Serialized<GenericEnvironment *>> GenericEnvironments;
 
+  /// Substitution maps referenced by this module.
+  std::vector<Serialized<SubstitutionMap>> SubstitutionMaps;
+
   /// Represents an identifier that may or may not have been deserialized yet.
   ///
   /// If \c Offset is non-zero, the identifier has not been loaded yet.
@@ -844,6 +847,10 @@ class ModuleFile
   GenericEnvironment *getGenericEnvironment(
                                         serialization::GenericEnvironmentID ID);
 
+  /// Returns the substitution map for the given ID, deserializing it if
+  /// needed.
+  SubstitutionMap getSubstitutionMap(serialization::SubstitutionMapID id);
+
   /// Reads a substitution record from \c DeclTypeCursor.
   ///
   /// If the record at the cursor is not a substitution, returns None.

include/swift/Serialization/ModuleFormat.h

@@ -88,6 +88,11 @@ using GenericSignatureIDField = DeclIDField;
 using GenericEnvironmentID = DeclID;
 using GenericEnvironmentIDField = DeclIDField;
 
+// SubstitutionMapID must be the same as DeclID because it is stored in the
+// same way.
+using SubstitutionMapID = DeclID;
+using SubstitutionMapIDField = DeclIDField;
+
 // ModuleID must be the same as IdentifierID because it is stored the same way.
 using ModuleID = IdentifierID;
 using ModuleIDField = IdentifierIDField;
@@ -1224,6 +1229,14 @@ namespace decls_block {
     BCArray<TypeIDField>         // generic parameter types
   >;
 
+  using SubstitutionMapLayout = BCRecordLayout<
+    SUBSTITUTION_MAP,
+    GenericSignatureIDField,     // generic signature
+    BCVBR<5>,                    // # of conformances
+    BCArray<TypeIDField>         // replacement types
+    // Conformances trail the record.
+  >;
+
   using SILGenericEnvironmentLayout = BCRecordLayout<
     SIL_GENERIC_ENVIRONMENT,
     BCArray<TypeIDField>         // (generic parameter name, sugared interface
@@ -1599,7 +1612,8 @@ namespace index_block {
     DECL_MEMBER_NAMES,
 
     GENERIC_SIGNATURE_OFFSETS,
-    LastRecordKind = GENERIC_SIGNATURE_OFFSETS,
+    SUBSTITUTION_MAP_OFFSETS,
+    LastRecordKind = SUBSTITUTION_MAP_OFFSETS,
   };
 
   constexpr const unsigned RecordIDFieldWidth = 5;

lib/Serialization/Deserialization.cpp

@@ -1097,7 +1097,77 @@ GenericEnvironment *ModuleFile::getGenericEnvironment(
                                        serialization::GenericEnvironmentID ID) {
   return getGenericSignatureOrEnvironment(ID, /*wantEnvironment=*/true)
            .get<GenericEnvironment *>();
-;
+}
+
+SubstitutionMap ModuleFile::getSubstitutionMap(
+                                        serialization::SubstitutionMapID id) {
+  using namespace decls_block;
+
+  // Zero is a sentinel for having an empty substitution map.
+  if (id == 0) return SubstitutionMap();
+
+  assert(id <= SubstitutionMaps.size() && "invalid SubstitutionMap ID");
+  auto &substitutionsOrOffset = SubstitutionMaps[id-1];
+
+  // If we've already deserialized this substitution map, return it.
+  if (substitutionsOrOffset.isComplete()) {
+    return substitutionsOrOffset.get();
+  }
+
+  // Read the substitution map.
+  BCOffsetRAII restoreOffset(DeclTypeCursor);
+  DeclTypeCursor.JumpToBit(substitutionsOrOffset);
+  DeserializingEntityRAII deserializingEntity(*this);
+
+  // Read the substitution map.
+  auto entry = DeclTypeCursor.advance(AF_DontPopBlockAtEnd);
+  if (entry.Kind != llvm::BitstreamEntry::Record) {
+    error();
+    return SubstitutionMap();
+  }
+
+  StringRef blobData;
+  SmallVector<uint64_t, 8> scratch;
+  unsigned recordID = DeclTypeCursor.readRecord(entry.ID, scratch, &blobData);
+  if (recordID != SUBSTITUTION_MAP) {
+    error();
+    return SubstitutionMap();
+  }
+
+  GenericSignatureID genericSigID;
+  uint64_t numConformances;
+  ArrayRef<uint64_t> replacementTypeIDs;
+  SubstitutionMapLayout::readRecord(scratch, genericSigID, numConformances,
+                                    replacementTypeIDs);
+
+  // Generic signature.
+  auto genericSig = getGenericSignature(genericSigID);
+  if (!genericSig) {
+    error();
+    return SubstitutionMap();
+  }
+
+  // Load the replacement types.
+  SmallVector<Type, 4> replacementTypes;
+  replacementTypes.reserve(replacementTypeIDs.size());
+  for (auto typeID : replacementTypeIDs) {
+    replacementTypes.push_back(getType(typeID));
+  }
+
+  // Read the conformances.
+  SmallVector<ProtocolConformanceRef, 4> conformances;
+  conformances.reserve(numConformances);
+  for (unsigned i : range(numConformances)) {
+    (void)i;
+    conformances.push_back(readConformance(DeclTypeCursor));
+  }
+
+  // Form the substitution map and record it.
+  auto substitutions =
+    SubstitutionMap::get(genericSig, ArrayRef<Type>(replacementTypes),
+                         ArrayRef<ProtocolConformanceRef>(conformances));
+  substitutionsOrOffset = substitutions;
+  return substitutions;
 }
 
 bool ModuleFile::readDefaultWitnessTable(ProtocolDecl *proto) {

lib/Serialization/ModuleFile.cpp

@@ -852,6 +852,10 @@ bool ModuleFile::readIndexBlock(llvm::BitstreamCursor &cursor) {
         assert(blobData.empty());
         GenericEnvironments.assign(scratch.begin(), scratch.end());
         break;
+      case index_block::SUBSTITUTION_MAP_OFFSETS:
+        assert(blobData.empty());
+        SubstitutionMaps.assign(scratch.begin(), scratch.end());
+        break;
       case index_block::NORMAL_CONFORMANCE_OFFSETS:
         assert(blobData.empty());
         NormalConformances.assign(scratch.begin(), scratch.end());