AST: Remove generic signature and conditional requirements from BuiltinProtocolConformance

Author: slavapestov

include/swift/AST/ASTContext.h

@@ -1276,8 +1276,6 @@ class ASTContext final {
   /// Produce the builtin conformance for some structural type to some protocol.
   BuiltinProtocolConformance *
   getBuiltinConformance(Type type, ProtocolDecl *protocol,
-                        GenericSignature genericSig,
-                        ArrayRef<Requirement> conditionalRequirements,
                         BuiltinConformanceKind kind);
 
   /// A callback used to produce a diagnostic for an ill-formed protocol

include/swift/AST/ProtocolConformance.h

@@ -1019,23 +1019,13 @@ enum class BuiltinConformanceKind {
 
 /// 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, Requirement> {
+class BuiltinProtocolConformance final : public RootProtocolConformance {
   friend ASTContext;
-  friend TrailingObjects;
 
   ProtocolDecl *protocol;
-  GenericSignature genericSig;
-  size_t numConditionalRequirements : 31;
-  unsigned builtinConformanceKind : 1;
-
-  size_t numTrailingObjects(OverloadToken<Requirement>) const {
-    return numConditionalRequirements;
-  }
+  unsigned builtinConformanceKind;
 
   BuiltinProtocolConformance(Type conformingType, ProtocolDecl *protocol,
-                             GenericSignature genericSig,
-                             ArrayRef<Requirement> conditionalRequirements,
                              BuiltinConformanceKind kind);
 
 public:
@@ -1044,16 +1034,14 @@ class BuiltinProtocolConformance final : public RootProtocolConformance,
     return protocol;
   }
 
-  /// Retrieve the generic signature that describes the type parameters used
-  /// within the conforming type.
-  GenericSignature getGenericSignature() const {
-    return genericSig;
-  }
-
   BuiltinConformanceKind getBuiltinConformanceKind() const {
     return static_cast<BuiltinConformanceKind>(builtinConformanceKind);
   }
 
+  GenericSignature getGenericSignature() const {
+    return GenericSignature();
+  }
+
   /// Whether this represents a "missing" conformance that should be diagnosed
   /// later.
   bool isMissing() const {
@@ -1063,12 +1051,12 @@ class BuiltinProtocolConformance final : public RootProtocolConformance,
   /// Get any requirements that must be satisfied for this conformance to apply.
   llvm::Optional<ArrayRef<Requirement>>
   getConditionalRequirementsIfAvailable() const {
-    return getConditionalRequirements();
+    return ArrayRef<Requirement>();
   }
 
   /// Get any requirements that must be satisfied for this conformance to apply.
   ArrayRef<Requirement> getConditionalRequirements() const {
-    return {getTrailingObjects<Requirement>(), numConditionalRequirements};
+    return {};
   }
 
   /// Get the declaration context that contains the nominal type declaration.

lib/AST/ASTContext.cpp

@@ -2681,23 +2681,15 @@ ASTContext::getSelfConformance(ProtocolDecl *protocol) {
 
 /// Produce the builtin conformance for some non-nominal to some protocol.
 BuiltinProtocolConformance *
-ASTContext::getBuiltinConformance(
-    Type type, ProtocolDecl *protocol,
-    GenericSignature genericSig,
-    ArrayRef<Requirement> conditionalRequirements,
-    BuiltinConformanceKind kind
-) {
+ASTContext::getBuiltinConformance(Type type, ProtocolDecl *protocol,
+                                  BuiltinConformanceKind kind) {
   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<Requirement>(conditionalRequirements.size());
-    auto mem = this->Allocate(size, alignof(BuiltinProtocolConformance), arena);
-    entry = new (mem) BuiltinProtocolConformance(
-        type, protocol, genericSig, conditionalRequirements, kind);
+    entry = new (*this) BuiltinProtocolConformance(type, protocol, kind);
   }
   return entry;
 }

lib/AST/Module.cpp

@@ -1588,7 +1588,7 @@ ModuleDecl::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   // All existentials are Copyable.
   if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), {},
+        ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
   }
 
@@ -1670,8 +1670,7 @@ ProtocolConformanceRef ProtocolConformanceRef::forMissingOrInvalid(
   if (shouldCreateMissingConformances(type, proto)) {
     return ProtocolConformanceRef(
         ctx.getBuiltinConformance(
-          type, proto, GenericSignature(), { },
-          BuiltinConformanceKind::Missing));
+          type, proto, BuiltinConformanceKind::Missing));
   }
 
   return ProtocolConformanceRef::forInvalid();
@@ -1774,15 +1773,15 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
   if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable) &&
       isSendableFunctionType(functionType)) {
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+        ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
   }
 
   // Functions cannot permanently destroy a move-only var/let
   // that they capture, so it's safe to copy functions, like classes.
   if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), {},
+        ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
   }
 
@@ -1799,14 +1798,14 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
   if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable) &&
       !metatypeType->getInstanceType()->isPureMoveOnly()) {
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+        ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
   }
 
   // All metatypes are Sendable
   if (protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+        ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
   }
 
@@ -1822,7 +1821,7 @@ static ProtocolConformanceRef getBuiltinBuiltinTypeConformance(
       protocol->isSpecificProtocol(KnownProtocolKind::Copyable)) {
     ASTContext &ctx = protocol->getASTContext();
     return ProtocolConformanceRef(
-        ctx.getBuiltinConformance(type, protocol, GenericSignature(), { },
+        ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
   }
 
@@ -1951,6 +1950,7 @@ LookupConformanceInModuleRequest::evaluate(
   }
 
   // Specific handling of Copyable and Sendable for pack expansions.
+  // FIXME: Remove.
   if (auto packExpansion = type->getAs<PackExpansionType>()) {
     if (protocol->isSpecificProtocol(KnownProtocolKind::Copyable) ||
         protocol->isSpecificProtocol(KnownProtocolKind::Sendable)) {

lib/AST/ProtocolConformance.cpp

@@ -967,18 +967,11 @@ ProtocolConformance::subst(InFlightSubstitution &IFS) const {
     if (substType.getPointer() == origType.getPointer())
       return const_cast<ProtocolConformance *>(this);
 
-    SmallVector<Requirement, 2> requirements;
-    for (auto req : getConditionalRequirements()) {
-      requirements.push_back(req.subst(IFS));
-    }
-
     auto kind = cast<BuiltinProtocolConformance>(this)
         ->getBuiltinConformanceKind();
 
     return substType->getASTContext()
-        .getBuiltinConformance(substType,
-                               getProtocol(), getGenericSignature(),
-                               requirements, kind);
+        .getBuiltinConformance(substType, getProtocol(), kind);
   }
   case ProtocolConformanceKind::Self:
     return const_cast<ProtocolConformance*>(this);
@@ -1410,18 +1403,7 @@ bool ProtocolConformance::isCanonical() const {
     return true;
   }
   case ProtocolConformanceKind::Builtin: {
-    // Check that the generic signature of the conformance is canonical.
-    auto builtinConformance = cast<BuiltinProtocolConformance>(this);
-    if (builtinConformance->getGenericSignature()
-        && !builtinConformance->getGenericSignature()->isCanonical()) {
-      return false;
-    }
-    // Check that the satisfied conditional requirements are canonical.
-    for (auto &requirement : builtinConformance->getConditionalRequirements()) {
-      if (!requirement.isCanonical()) {
-        return false;
-      }
-    }
+    // FIXME: Not the conforming type?
     return true;
   }
   case ProtocolConformanceKind::Inherited: {
@@ -1458,15 +1440,9 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
     // Canonicalize the subject type of the builtin conformance.
     auto &Ctx = getType()->getASTContext();
     auto builtinConformance = cast<BuiltinProtocolConformance>(this);
-    SmallVector<Requirement, 4> canonicalRequirements;
-    for (auto &reqt : builtinConformance->getConditionalRequirements()) {
-      canonicalRequirements.push_back(reqt.getCanonical());
-    }
     return Ctx.getBuiltinConformance(
       builtinConformance->getType()->getCanonicalType(),
       builtinConformance->getProtocol(),
-      builtinConformance->getGenericSignature().getCanonicalSignature(),
-      canonicalRequirements,
       builtinConformance->getBuiltinConformanceKind());
   }
 
@@ -1496,18 +1472,10 @@ ProtocolConformance *ProtocolConformance::getCanonicalConformance() {
 
 BuiltinProtocolConformance::BuiltinProtocolConformance(
     Type conformingType, ProtocolDecl *protocol,
-    GenericSignature genericSig,
-    ArrayRef<Requirement> conditionalRequirements,
     BuiltinConformanceKind kind
 ) : RootProtocolConformance(ProtocolConformanceKind::Builtin, conformingType),
-    protocol(protocol), genericSig(genericSig),
-    numConditionalRequirements(conditionalRequirements.size()),
-    builtinConformanceKind(static_cast<unsigned>(kind))
-{
-  std::uninitialized_copy(conditionalRequirements.begin(),
-                          conditionalRequirements.end(),
-                          getTrailingObjects<Requirement>());
-}
+    protocol(protocol), builtinConformanceKind(static_cast<unsigned>(kind))
+{}
 
 // See swift/Basic/Statistic.h for declaration: this enables tracing
 // ProtocolConformances, is defined here to avoid too much layering violation /

lib/Sema/TypeCheckProtocol.cpp

@@ -5700,8 +5700,7 @@ TypeChecker::containsProtocol(Type T, ProtocolDecl *Proto, ModuleDecl *M,
         Proto->isSpecificProtocol(KnownProtocolKind::Sendable)) {
       return ProtocolConformanceRef(
           M->getASTContext().getBuiltinConformance(
-            T, Proto, GenericSignature(), { },
-            BuiltinConformanceKind::Missing));
+            T, Proto, BuiltinConformanceKind::Missing));
     }
 
     return ProtocolConformanceRef::forInvalid();

lib/Serialization/Deserialization.cpp

@@ -844,13 +844,9 @@ ProtocolConformanceDeserializer::readBuiltinProtocolConformance(
 
   TypeID conformingTypeID;
   DeclID protoID;
-  GenericSignatureID genericSigID;
   unsigned builtinConformanceKind;
-  ArrayRef<uint64_t> data;
   BuiltinProtocolConformanceLayout::readRecord(scratch, conformingTypeID,
-                                               protoID, genericSigID,
-                                               builtinConformanceKind,
-                                               data);
+                                               protoID, builtinConformanceKind);
 
   Type conformingType = MF.getType(conformingTypeID);
 
@@ -859,22 +855,9 @@ ProtocolConformanceDeserializer::readBuiltinProtocolConformance(
     return decl.takeError();
 
   auto proto = cast<ProtocolDecl>(decl.get());
-  auto genericSig = MF.getGenericSignatureChecked(genericSigID);
-  if (!genericSig)
-    return genericSig.takeError();
-
-  // Read the conditional requirements.
-  SmallVector<Requirement, 4> conditionalRequirements;
-  unsigned nextDataIndex = 0;
-  auto error = MF.deserializeGenericRequirementsChecked(
-      data, nextDataIndex, conditionalRequirements);
-  if (error)
-    return std::move(error);
-  if (nextDataIndex != data.size())
-    return MF.diagnoseFatal();
 
   auto conformance = ctx.getBuiltinConformance(
-      conformingType, proto, *genericSig, conditionalRequirements,
+      conformingType, proto,
       static_cast<BuiltinConformanceKind>(builtinConformanceKind));
   return conformance;
 }

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 = 797; // checked_cast_br takes a formal type
+const uint16_t SWIFTMODULE_VERSION_MINOR = 798; // removing builtin tuple conformances
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1951,9 +1951,7 @@ namespace decls_block {
     BUILTIN_PROTOCOL_CONFORMANCE,
     TypeIDField, // the conforming type
     DeclIDField, // the protocol
-    GenericSignatureIDField, // the generic signature
-    BCFixed<2>, // the builtin conformance kind
-    BCArray<BCVBR<6>> // conditional requirements
+    BCFixed<2>  // the builtin conformance kind
   >;
 
   using PackConformanceLayout = BCRecordLayout<

lib/Serialization/Serialization.cpp

@@ -1842,16 +1842,10 @@ Serializer::writeASTBlockEntity(ProtocolConformance *conformance) {
       DeclTypeAbbrCodes[BuiltinProtocolConformanceLayout::Code];
     auto typeID = addTypeRef(builtin->getType());
     auto protocolID = addDeclRef(builtin->getProtocol());
-    auto genericSigID = addGenericSignatureRef(builtin->getGenericSignature());
-
-    SmallVector<uint64_t, 16> requirementData;
-    serializeGenericRequirements(builtin->getConditionalRequirements(),
-                                 requirementData);
 
     BuiltinProtocolConformanceLayout::emitRecord(
-        Out, ScratchRecord, abbrCode, typeID, protocolID, genericSigID,
-        static_cast<unsigned>(builtin->getBuiltinConformanceKind()),
-        requirementData);
+        Out, ScratchRecord, abbrCode, typeID, protocolID,
+        static_cast<unsigned>(builtin->getBuiltinConformanceKind()));
     break;
   }
 }