Serialization: Round-trip the RequirementMachine's ProtocolTypeAlias records

Author: slavapestov

include/swift/AST/LazyResolver.h

@@ -17,7 +17,6 @@
 #ifndef SWIFT_AST_LAZYRESOLVER_H
 #define SWIFT_AST_LAZYRESOLVER_H
 
-#include "swift/AST/ProtocolConformanceRef.h"
 #include "llvm/ADT/PointerEmbeddedInt.h"
 
 namespace swift {
@@ -32,6 +31,7 @@ class NominalTypeDecl;
 class NormalProtocolConformance;
 class ProtocolConformance;
 class ProtocolDecl;
+class ProtocolTypeAlias;
 class TypeDecl;
 class ValueDecl;
 class VarDecl;
@@ -99,7 +99,8 @@ class alignas(void*) LazyMemberLoader {
   /// Loads the requirement signature for a protocol.
   virtual void
   loadRequirementSignature(const ProtocolDecl *proto, uint64_t contextData,
-                           SmallVectorImpl<Requirement> &requirements) = 0;
+                           SmallVectorImpl<Requirement> &requirements,
+                           SmallVectorImpl<ProtocolTypeAlias> &typeAliases) = 0;
 
   /// Loads the associated types of a protocol.
   virtual void

lib/AST/GenericSignatureBuilder.cpp

@@ -8602,12 +8602,13 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
     auto contextData = static_cast<LazyProtocolData *>(
         ctx.getOrCreateLazyContextData(proto, nullptr));
 
-    SmallVector<Requirement, 8> requirements;
+    SmallVector<Requirement, 2> requirements;
+    SmallVector<ProtocolTypeAlias, 2> typeAliases;
     contextData->loader->loadRequirementSignature(
-        proto, contextData->requirementSignatureData, requirements);
-    if (requirements.empty())
-      return RequirementSignature();
-    return RequirementSignature(ctx.AllocateCopy(requirements), None);
+        proto, contextData->requirementSignatureData,
+        requirements, typeAliases);
+    return RequirementSignature(ctx.AllocateCopy(requirements),
+                                ctx.AllocateCopy(typeAliases));
   }
 
   auto buildViaGSB = [&]() {

lib/ClangImporter/ImporterImpl.h

@@ -26,6 +26,7 @@
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/LazyResolver.h"
 #include "swift/AST/Module.h"
+#include "swift/AST/RequirementSignature.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/FileTypes.h"
 #include "swift/Basic/StringExtras.h"
@@ -1516,7 +1517,8 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   }
 
   void loadRequirementSignature(const ProtocolDecl *decl, uint64_t contextData,
-                                SmallVectorImpl<Requirement> &reqs) override {
+                                SmallVectorImpl<Requirement> &reqs,
+                                SmallVectorImpl<ProtocolTypeAlias> &typeAliases) override {
     llvm_unreachable("unimplemented for ClangImporter");
   }
 

lib/Serialization/DeclTypeRecordNodes.def

@@ -127,6 +127,7 @@ DECL(OPAQUE_TYPE)
 DECL(PATTERN_BINDING)
 DECL(PROTOCOL)
 TRAILING_INFO(DEFAULT_WITNESS_TABLE)
+TRAILING_INFO(PROTOCOL_TYPEALIAS)
 TRAILING_INFO(ASSOCIATED_TYPE)
 DECL(PREFIX_OPERATOR)
 DECL(POSTFIX_OPERATOR)

lib/Serialization/Deserialization.cpp

@@ -889,6 +889,53 @@ llvm::Error ModuleFile::readGenericRequirementsChecked(
   return llvm::Error::success();
 }
 
+void ModuleFile::readRequirementSignature(
+                   SmallVectorImpl<Requirement> &requirements,
+                   SmallVectorImpl<ProtocolTypeAlias> &typeAliases,
+                   llvm::BitstreamCursor &Cursor) {
+  readGenericRequirements(requirements, Cursor);
+
+  using namespace decls_block;
+
+  BCOffsetRAII lastRecordOffset(Cursor);
+  SmallVector<uint64_t, 8> scratch;
+  StringRef blobData;
+
+  while (true) {
+    lastRecordOffset.reset();
+    bool shouldContinue = true;
+
+    llvm::BitstreamEntry entry =
+        fatalIfUnexpected(Cursor.advance(AF_DontPopBlockAtEnd));
+    if (entry.Kind != llvm::BitstreamEntry::Record)
+      break;
+
+    scratch.clear();
+    unsigned recordID = fatalIfUnexpected(
+        Cursor.readRecord(entry.ID, scratch, &blobData));
+    switch (recordID) {
+    case PROTOCOL_TYPEALIAS: {
+      uint64_t rawName;
+      uint64_t rawTypeID;
+      ProtocolTypeAliasLayout::readRecord(scratch, rawName, rawTypeID);
+
+      auto name = getIdentifier(rawName);
+      auto underlyingType = getType(rawTypeID);
+
+      typeAliases.emplace_back(name, underlyingType);
+      break;
+    }
+    default:
+      // This record is not part of the protocol requirement signature.
+      shouldContinue = false;
+      break;
+    }
+
+    if (!shouldContinue)
+      break;
+  }
+}
+
 void ModuleFile::readAssociatedTypes(
                    SmallVectorImpl<AssociatedTypeDecl *> &assocTypes,
                    llvm::BitstreamCursor &Cursor) {
@@ -919,8 +966,10 @@ void ModuleFile::readAssociatedTypes(
   }
 }
 
-/// Advances past any records that might be part of a requirement signature.
-static llvm::Error skipGenericRequirements(llvm::BitstreamCursor &Cursor) {
+/// Advances past any records that might be part of a protocol requirement
+/// signature, which consists of generic requirements together with protocol
+/// typealias records.
+static llvm::Error skipRequirementSignature(llvm::BitstreamCursor &Cursor) {
   using namespace decls_block;
 
   BCOffsetRAII lastRecordOffset(Cursor);
@@ -940,6 +989,7 @@ static llvm::Error skipGenericRequirements(llvm::BitstreamCursor &Cursor) {
     switch (maybeRecordID.get()) {
     case GENERIC_REQUIREMENT:
     case LAYOUT_REQUIREMENT:
+    case PROTOCOL_TYPEALIAS:
       break;
 
     default:
@@ -3611,7 +3661,7 @@ class DeclDeserializer {
 
     proto->setLazyRequirementSignature(&MF,
                                        MF.DeclTypeCursor.GetCurrentBitNo());
-    if (llvm::Error Err = skipGenericRequirements(MF.DeclTypeCursor))
+    if (llvm::Error Err = skipRequirementSignature(MF.DeclTypeCursor))
       MF.fatal(std::move(Err));
 
     proto->setLazyAssociatedTypeMembers(&MF,
@@ -6755,10 +6805,11 @@ void ModuleFile::finishNormalConformance(NormalProtocolConformance *conformance,
 
 void ModuleFile::loadRequirementSignature(const ProtocolDecl *decl,
                                           uint64_t contextData,
-                                          SmallVectorImpl<Requirement> &reqs) {
+                                          SmallVectorImpl<Requirement> &reqs,
+                                          SmallVectorImpl<ProtocolTypeAlias> &typeAliases) {
   BCOffsetRAII restoreOffset(DeclTypeCursor);
   fatalIfNotSuccess(DeclTypeCursor.JumpToBit(contextData));
-  readGenericRequirements(reqs, DeclTypeCursor);
+  readRequirementSignature(reqs, typeAliases, DeclTypeCursor);
 }
 
 void ModuleFile::loadAssociatedTypes(const ProtocolDecl *decl,

lib/Serialization/ModuleFile.h

@@ -398,6 +398,12 @@ class ModuleFile
   readGenericRequirementsChecked(SmallVectorImpl<Requirement> &requirements,
                                  llvm::BitstreamCursor &Cursor);
 
+  /// Read the requirement signature of a protocol, which consists of a list of
+  /// generic requirements and a list of protocol typealias records.
+  void readRequirementSignature(SmallVectorImpl<Requirement> &requirements,
+                                SmallVectorImpl<ProtocolTypeAlias> &typeAliases,
+                                llvm::BitstreamCursor &Cursor);
+
   /// Read a list of associated type declarations in a protocol.
   void readAssociatedTypes(SmallVectorImpl<AssociatedTypeDecl *> &assocTypes,
                            llvm::BitstreamCursor &Cursor);
@@ -728,7 +734,8 @@ class ModuleFile
 
   void
   loadRequirementSignature(const ProtocolDecl *proto, uint64_t contextData,
-                           SmallVectorImpl<Requirement> &requirements) override;
+                           SmallVectorImpl<Requirement> &requirements,
+                           SmallVectorImpl<ProtocolTypeAlias> &typeAliases) override;
 
   void
   loadAssociatedTypes(const ProtocolDecl *proto, uint64_t contextData,

lib/Serialization/ModuleFormat.h

@@ -56,7 +56,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 = 668; // @_nonSendable fix
+const uint16_t SWIFTMODULE_VERSION_MINOR = 669; // RequirementMachine protocol typealiases
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1654,6 +1654,12 @@ namespace decls_block {
     BCVBR<8>                     // alignment
   >;
 
+  using ProtocolTypeAliasLayout = BCRecordLayout<
+    PROTOCOL_TYPEALIAS,
+    IdentifierIDField,           // name
+    TypeIDField                  // underlying type
+  >;
+
   using AssociatedTypeLayout = BCRecordLayout<
     ASSOCIATED_TYPE,
     DeclIDField                  // associated type decl

lib/Serialization/Serialization.cpp

@@ -1418,6 +1418,23 @@ void Serializer::writeAssociatedTypes(ArrayRef<AssociatedTypeDecl *> assocTypes,
   }
 }
 
+void Serializer::writeRequirementSignature(
+    const RequirementSignature &requirementSig,
+    const std::array<unsigned, 256> &abbrCodes) {
+  writeGenericRequirements(requirementSig.getRequirements(), abbrCodes);
+
+  using namespace decls_block;
+
+  auto protocolTypeAliasAbbrCode = abbrCodes[ProtocolTypeAliasLayout::Code];
+
+  for (const auto &typeAlias : requirementSig.getTypeAliases()) {
+    ProtocolTypeAliasLayout::emitRecord(
+        Out, ScratchRecord, protocolTypeAliasAbbrCode,
+        addDeclBaseNameRef(typeAlias.getName()),
+        addTypeRef(typeAlias.getUnderlyingType()));
+  }
+}
+
 void Serializer::writeASTBlockEntity(GenericSignature sig) {
   using namespace decls_block;
 
@@ -3633,14 +3650,20 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
         dependencyTypes.insert(elementType);
     }
 
-    for (Requirement req : proto->getRequirementSignature().getRequirements()) {
+    auto requirementSig = proto->getRequirementSignature();
+    for (Requirement req : requirementSig.getRequirements()) {
       // Requirements can be cyclic, so for now filter out any requirements
       // from elsewhere in the module. This isn't perfect---something else in
       // the module could very well fail to compile for its own reasons---but
       // it's better than nothing.
       collectDependenciesFromRequirement(dependencyTypes, req,
                                          /*excluding*/S.M);
     }
+    for (ProtocolTypeAlias typeAlias : requirementSig.getTypeAliases()) {
+      collectDependenciesFromType(dependencyTypes,
+                                  typeAlias.getUnderlyingType(),
+                                  /*excluding*/S.M);
+    }
 
     for (Type ty : dependencyTypes)
       inheritedAndDependencyTypes.push_back(S.addTypeRef(ty));
@@ -3660,8 +3683,8 @@ class Serializer::DeclSerializer : public DeclVisitor<DeclSerializer> {
                                inheritedAndDependencyTypes);
 
     writeGenericParams(proto->getGenericParams());
-    S.writeGenericRequirements(
-      proto->getRequirementSignature().getRequirements(), S.DeclTypeAbbrCodes);
+    S.writeRequirementSignature(
+      proto->getRequirementSignature(), S.DeclTypeAbbrCodes);
     S.writeAssociatedTypes(
       proto->getAssociatedTypeMembers(), S.DeclTypeAbbrCodes);
     writeMembers(id, proto->getAllMembers(), true);
@@ -4958,6 +4981,7 @@ void Serializer::writeAllDeclsAndTypes() {
   registerDeclTypeAbbr<OpaqueTypeLayout>();
   registerDeclTypeAbbr<PatternBindingLayout>();
   registerDeclTypeAbbr<ProtocolLayout>();
+  registerDeclTypeAbbr<ProtocolTypeAliasLayout>();
   registerDeclTypeAbbr<AssociatedTypeLayout>();
   registerDeclTypeAbbr<DefaultWitnessTableLayout>();
   registerDeclTypeAbbr<PrefixOperatorLayout>();

lib/Serialization/Serialization.h

@@ -21,6 +21,7 @@
 #include "swift/Serialization/SerializationOptions.h"
 #include "swift/Subsystems.h"
 #include "swift/AST/Identifier.h"
+#include "swift/AST/RequirementSignature.h"
 #include "swift/Basic/LLVM.h"
 #include "llvm/ADT/MapVector.h"
 #include <array>
@@ -539,6 +540,11 @@ class Serializer : public SerializerBase {
   void writeGenericRequirements(ArrayRef<Requirement> requirements,
                                 const std::array<unsigned, 256> &abbrCodes);
 
+  /// Writes a protocol's requirement signature, consisting of a list of
+  /// generic requirements and a list of protocol typealias records.
+  void writeRequirementSignature(const RequirementSignature &requirementSig,
+                                 const std::array<unsigned, 256> &abbrCodes);
+
   /// Writes a protocol's associated type table.
   void writeAssociatedTypes(ArrayRef<AssociatedTypeDecl *> assocTypes,
                             const std::array<unsigned, 256> &abbrCodes);