[AST] Store and serialize a protocol's requirement signature.

This is the "canonical" representation of the type-level requirements of
a protocol, and we intend to use it pervasively in the compiler.

Author: huonw

include/swift/AST/Decl.h

@@ -3392,6 +3392,10 @@ class ProtocolDecl : public NominalTypeDecl {
 
   llvm::DenseMap<ValueDecl *, Witness> DefaultWitnesses;
 
+  /// The generic signature representing exactly the new requirements introduced
+  /// by this protocol.
+  GenericSignature *RequirementSignature = nullptr;
+
   /// True if the protocol has requirements that cannot be satisfied (e.g.
   /// because they could not be imported from Objective-C).
   unsigned HasMissingRequirements : 1;
@@ -3585,7 +3589,17 @@ class ProtocolDecl : public NominalTypeDecl {
   /// for associated types that are mentioned literally in this
   /// decl. Requirements implied via inheritance are not mentioned, nor is the
   /// conformance of Self to this protocol.
-  GenericSignature *getRequirementSignature();
+  GenericSignature *getRequirementSignature() const {
+    assert(RequirementSignature &&
+           "getting requirement signature before computing it");
+    return RequirementSignature;
+  }
+
+  void computeRequirementSignature();
+
+  void setRequirementSignature(GenericSignature *sig) {
+    RequirementSignature = sig;
+  }
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {

include/swift/Serialization/ModuleFormat.h

@@ -54,7 +54,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// 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.
-const uint16_t VERSION_MINOR = 311; // Last change: unmanaged autorelease value
+const uint16_t VERSION_MINOR = 312; // Last change: serialize requirement signatures
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;

lib/AST/Decl.cpp

@@ -3005,16 +3005,22 @@ void ProtocolDecl::createGenericParamsIfMissing() {
     setGenericParams(createGenericParams(this));
 }
 
-GenericSignature *ProtocolDecl::getRequirementSignature() {
+void ProtocolDecl::computeRequirementSignature() {
+  assert(!RequirementSignature && "already computed requirement signature");
+
   auto module = getParentModule();
 
   auto genericSig = getGenericSignature();
   // The signature should look like <Self where Self : ThisProtocol>, and we
   // reuse the two parts of it because the parameter and the requirement are
   // exactly what we need.
-  assert(genericSig->getGenericParams().size() == 1 &&
-         genericSig->getRequirements().size() == 1 &&
-         "getRequirementSignature with unexpected generic signature");
+  auto validSig = genericSig->getGenericParams().size() == 1 &&
+                  genericSig->getRequirements().size() == 1;
+  if (!validSig) {
+    // This doesn't look like a protocol we can handle, so some other error must
+    // have occured (usually a protocol nested within another declaration)
+    return;
+  }
 
   auto selfType = genericSig->getGenericParams()[0];
   auto requirement = genericSig->getRequirements()[0];
@@ -3027,7 +3033,7 @@ GenericSignature *ProtocolDecl::getRequirementSignature() {
   builder.addRequirement(requirement, source);
   builder.finalize(SourceLoc(), { selfType });
 
-  return builder.getGenericSignature();
+  RequirementSignature = builder.getGenericSignature();
 }
 
 /// Returns the default witness for a requirement, or nullptr if there is

lib/Sema/TypeCheckDecl.cpp

@@ -7080,6 +7080,8 @@ void TypeChecker::validateDecl(ValueDecl *D) {
       markAsObjC(*this, proto, isObjC);
     }
 
+    proto->computeRequirementSignature();
+
     ValidatedTypes.insert(proto);
     break;
   }

lib/Serialization/Deserialization.cpp

@@ -3059,8 +3059,16 @@ Decl *ModuleFile::getDecl(DeclID DID, Optional<DeclContext *> ForcedContext) {
 
     handleInherited(proto, rawProtocolAndInheritedIDs.slice(numProtocols));
 
-    if (auto genericParams = maybeReadGenericParams(DC))
-      proto->setGenericParams(genericParams);
+    auto genericParams = maybeReadGenericParams(DC);
+    assert(genericParams && "protocol with no generic parameters?");
+    proto->setGenericParams(genericParams);
+
+    SmallVector<Requirement, 4> requirements;
+    readGenericRequirements(requirements, DeclTypeCursor);
+
+    auto signature = GenericSignature::get(
+        proto->getGenericEnvironment()->getGenericParams(), requirements);
+    proto->setRequirementSignature(signature);
 
     if (isImplicit)
       proto->setImplicit();

lib/Serialization/Serialization.cpp

@@ -2661,6 +2661,8 @@ void Serializer::writeDecl(const Decl *D) {
                                protocolsAndInherited);
 
     writeGenericParams(proto->getGenericParams());
+    writeGenericRequirements(
+        proto->getRequirementSignature()->getRequirements(), DeclTypeAbbrCodes);
     writeMembers(proto->getMembers(), true);
     writeDefaultWitnessTable(proto, DeclTypeAbbrCodes);
     break;