Rework BuiltinProtocolConformance to be more like NormalProtocolConformance.

Give BuiltinProtocolConformance a generic signature, which can be used to
describe the generic parameters used within the builtin conformance, e.g.,
`<T1, T2, T3>` for a tuple type `(T1, T2, T3)`. Also store the
conditional requirements as trailing objects, requiring them to be
precomputed by whatever builds the conformances. Together, this means
that builtin protocol conformances act like normal conformances with
respect to conditional requirements and substitutions: they will be
defined generically, then a specialized conformance will be layered on
top to provide the substitutions.

Author: DougGregor

include/swift/AST/ASTContext.h

@@ -1033,7 +1033,8 @@ class ASTContext final {
   /// Produce the builtin conformance for some structural type to some protocol.
   BuiltinProtocolConformance *
   getBuiltinConformance(Type type, ProtocolDecl *protocol,
-                        ArrayRef<ProtocolConformanceRef> conformances);
+                        GenericSignature genericSig,
+                        ArrayRef<Requirement> conditionalRequirements);
 
   /// A callback used to produce a diagnostic for an ill-formed protocol
   /// conformance that was type-checked before we're actually walking the

include/swift/AST/ProtocolConformance.h

@@ -996,47 +996,44 @@ class InheritedProtocolConformance : public ProtocolConformance,
 /// A builtin conformance appears when a non-nominal type has a
 /// conformance that is synthesized by the implementation.
 class BuiltinProtocolConformance final : public RootProtocolConformance,
-      private llvm::TrailingObjects<BuiltinProtocolConformance,
-                                    ProtocolConformanceRef> {
+      private llvm::TrailingObjects<BuiltinProtocolConformance, Requirement> {
   friend ASTContext;
   friend TrailingObjects;
 
-  ProtocolDecl *protocol = nullptr;
-  size_t numConformances;
+  ProtocolDecl *protocol;
+  GenericSignature genericSig;
+  size_t numConditionalRequirements;
 
-  mutable Optional<ArrayRef<Requirement>> conditionalConformances = None;
+  size_t numTrailingObjects(OverloadToken<Requirement>) const {
+    return numConditionalRequirements;
+  }
 
   BuiltinProtocolConformance(Type conformingType, ProtocolDecl *protocol,
-                             ArrayRef<ProtocolConformanceRef> conformances);
-
-  size_t numTrailingObjects(OverloadToken<ProtocolConformanceRef>) const {
-    return numConformances;
-  }
+                             GenericSignature genericSig,
+                             ArrayRef<Requirement> conditionalRequirements);
 
 public:
   /// Get the protocol being conformed to.
   ProtocolDecl *getProtocol() const {
     return protocol;
   }
 
-  /// Get the trailing conformances that this builtin conformance needs.
-  MutableArrayRef<ProtocolConformanceRef> getConformances() {
-    return {getTrailingObjects<ProtocolConformanceRef>(), numConformances};
-  }
-
-  /// Get the trailing conformances that this builtin conformance needs.
-  ArrayRef<ProtocolConformanceRef> getConformances() const {
-    return {getTrailingObjects<ProtocolConformanceRef>(), numConformances};
+  /// Retrieve the generic signature that describes the type parameters used
+  /// within the conforming type.
+  GenericSignature getGenericSignature() const {
+    return genericSig;
   }
 
   /// Get any requirements that must be satisfied for this conformance to apply.
   Optional<ArrayRef<Requirement>>
   getConditionalRequirementsIfAvailable() const {
-    return ArrayRef<Requirement>();
+    return getConditionalRequirements();
   }
 
   /// Get any requirements that must be satisfied for this conformance to apply.
-  ArrayRef<Requirement> getConditionalRequirements() const;
+  ArrayRef<Requirement> getConditionalRequirements() const {
+    return {getTrailingObjects<Requirement>(), numConditionalRequirements};
+  }
 
   /// Get the declaration context that contains the nominal type declaration.
   DeclContext *getDeclContext() const {

lib/AST/ASTContext.cpp

@@ -2249,18 +2249,22 @@ ASTContext::getSelfConformance(ProtocolDecl *protocol) {
 
 /// Produce the builtin conformance for some non-nominal to some protocol.
 BuiltinProtocolConformance *
-ASTContext::getBuiltinConformance(Type type, ProtocolDecl *protocol,
-                                ArrayRef<ProtocolConformanceRef> conformances) {
+ASTContext::getBuiltinConformance(
+    Type type, ProtocolDecl *protocol,
+    GenericSignature genericSig,
+    ArrayRef<Requirement> conditionalRequirements
+) {
   auto key = std::make_pair(type, protocol);
   AllocationArena arena = getArena(type->getRecursiveProperties());
   auto &builtinConformances = getImpl().getArena(arena).BuiltinConformances;
 
   auto &entry = builtinConformances[key];
   if (!entry) {
     auto size = BuiltinProtocolConformance::
-        totalSizeToAlloc<ProtocolConformanceRef>(conformances.size());
+        totalSizeToAlloc<Requirement>(conditionalRequirements.size());
     auto mem = this->Allocate(size, alignof(BuiltinProtocolConformance), arena);
-    entry = new (mem) BuiltinProtocolConformance(type, protocol, conformances);
+    entry = new (mem) BuiltinProtocolConformance(
+        type, protocol, genericSig, conditionalRequirements);
   }
   return entry;
 }

lib/AST/ProtocolConformance.cpp

@@ -326,8 +326,10 @@ GenericSignature ProtocolConformance::getGenericSignature() const {
     // generic signature.
     return getDeclContext()->getGenericSignatureOfContext();
 
-  case ProtocolConformanceKind::Specialized:
   case ProtocolConformanceKind::Builtin:
+    return cast<BuiltinProtocolConformance>(this)->getGenericSignature();
+
+  case ProtocolConformanceKind::Specialized:
     // If we have a specialized protocol conformance, since we do not support
     // currently partial specialization, we know that it cannot have any open
     // type variables.
@@ -1582,33 +1584,14 @@ ProtocolConformanceRef::getCanonicalConformanceRef() const {
 
 BuiltinProtocolConformance::BuiltinProtocolConformance(
     Type conformingType, ProtocolDecl *protocol,
-    ArrayRef<ProtocolConformanceRef> conformances) : 
-      RootProtocolConformance(ProtocolConformanceKind::Builtin, conformingType),
-      protocol(protocol), numConformances(conformances.size()) {
-  std::uninitialized_copy(conformances.begin(), conformances.end(),
-                          getTrailingObjects<ProtocolConformanceRef>());
-}
-
-ArrayRef<Requirement>
-BuiltinProtocolConformance::getConditionalRequirements() const {
-  if (conditionalConformances == None) {
-    // Right now only tuples are builtin and have conditional conformances.
-    if (auto tuple = getType()->getAs<TupleType>()) {
-      SmallVector<Requirement, 4> requirements;
-
-      for (size_t i = 0; i != getConformances().size(); i += 1) {
-        auto req = Requirement(RequirementKind::Conformance,
-                               tuple->getElement(i).getType(),
-                               getProtocol()->getDeclaredType());
-        requirements.push_back(req);
-      }
-
-      conditionalConformances = getProtocol()->getASTContext()
-                                             .AllocateCopy(requirements);
-    }
-  }
-
-  return *conditionalConformances;
+    GenericSignature genericSig,
+    ArrayRef<Requirement> conditionalRequirements
+) : RootProtocolConformance(ProtocolConformanceKind::Builtin, conformingType),
+    protocol(protocol), genericSig(genericSig),
+    numConditionalRequirements(conditionalRequirements.size()) {
+  std::uninitialized_copy(conditionalRequirements.begin(),
+                          conditionalRequirements.end(),
+                          getTrailingObjects<Requirement>());
 }
 
 // See swift/Basic/Statistic.h for declaration: this enables tracing

lib/Sema/CSSimplify.cpp

@@ -6186,8 +6186,7 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyConformsToConstraint(
 
     // This conformance may be conditional, in which case we need to consider
     // those requirements as constraints too.
-    if (conformance.isConcrete() &&
-        !isa<BuiltinProtocolConformance>(conformance.getConcrete())) {
+    if (conformance.isConcrete()) {
       unsigned index = 0;
       auto *conformanceLoc = getConstraintLocator(
           loc,

lib/Serialization/DeclTypeRecordNodes.def

@@ -168,7 +168,7 @@ OTHER(GENERIC_PARAM_LIST, 230)
 OTHER(GENERIC_SIGNATURE, 231)
 TRAILING_INFO(GENERIC_REQUIREMENT)
 TRAILING_INFO(LAYOUT_REQUIREMENT)
-// 234 is unused
+OTHER(BUILTIN_PROTOCOL_CONFORMANCE, 234)
 OTHER(SIL_GENERIC_SIGNATURE, 235)
 OTHER(SUBSTITUTION_MAP, 236)
 
@@ -198,8 +198,6 @@ OTHER(DERIVATIVE_FUNCTION_CONFIGURATION, 254)
 
 OTHER(ERROR_FLAG, 255)
 
-OTHER(BUILTIN_PROTOCOL_CONFORMANCE, 256)
-
 #undef RECORD
 #undef DECLTYPERECORDNODES_HAS_RECORD_VAL
 #undef RECORD_VAL

lib/Serialization/Deserialization.cpp

@@ -546,9 +546,9 @@ ModuleFile::readConformanceChecked(llvm::BitstreamCursor &Cursor,
   case BUILTIN_PROTOCOL_CONFORMANCE: {
     TypeID conformingTypeID;
     DeclID protoID;
-    size_t numConformances;
+    GenericSignatureID genericSigID;
     BuiltinProtocolConformanceLayout::readRecord(scratch, conformingTypeID,
-                                                 protoID, numConformances);
+                                                 protoID, genericSigID);
 
     Type conformingType = getType(conformingTypeID);
 
@@ -557,17 +557,19 @@ ModuleFile::readConformanceChecked(llvm::BitstreamCursor &Cursor,
       return decl.takeError();
 
     auto proto = cast<ProtocolDecl>(decl.get());
-
-    // Read the conformances.
-    SmallVector<ProtocolConformanceRef, 4> conformances;
-    conformances.reserve(numConformances);
-    for (unsigned i : range(numConformances)) {
-      (void)i;
-      conformances.push_back(readConformance(Cursor));
-    }
-
-    auto conformance = getContext().getBuiltinConformance(conformingType, proto,
-                                                          conformances);
+    auto genericSig = getGenericSignatureChecked(genericSigID);
+    if (!genericSig)
+      return genericSig.takeError();
+
+    // Read the conditional requirements.
+    SmallVector<Requirement, 4> conditionalRequirements;
+    auto error = readGenericRequirementsChecked(
+        conditionalRequirements, Cursor);
+    if (error)
+      return std::move(error);
+
+    auto conformance = getContext().getBuiltinConformance(
+        conformingType, proto, *genericSig, conditionalRequirements);
     return ProtocolConformanceRef(conformance);
   }
 

lib/Serialization/ModuleFormat.h

@@ -1675,8 +1675,8 @@ namespace decls_block {
     BUILTIN_PROTOCOL_CONFORMANCE,
     TypeIDField, // the conforming type
     DeclIDField, // the protocol
-    BCVBR<5> // the number of element conformances
-    // the (optional) element conformances follow
+    GenericSignatureIDField // the generic signature
+    // the (optional) conditional requirements follow
   >;
 
   // Refers to a normal protocol conformance in the given module via its id.

lib/Serialization/Serialization.cpp

@@ -1610,11 +1610,10 @@ Serializer::writeConformance(ProtocolConformanceRef conformanceRef,
     unsigned abbrCode = abbrCodes[BuiltinProtocolConformanceLayout::Code];
     auto typeID = addTypeRef(builtin->getType());
     auto protocolID = addDeclRef(builtin->getProtocol());
-    BuiltinProtocolConformanceLayout::emitRecord(Out, ScratchRecord, abbrCode,
-                                                 typeID, protocolID,
-                                             builtin->getConformances().size());
-
-    writeConformances(builtin->getConformances(), abbrCodes);
+    auto genericSigID = addGenericSignatureRef(builtin->getGenericSignature());
+    BuiltinProtocolConformanceLayout::emitRecord(
+        Out, ScratchRecord, abbrCode, typeID, protocolID, genericSigID);
+    writeGenericRequirements(builtin->getConditionalRequirements(), abbrCodes);
     break;
   }
 }