[ABI] Add associated conformance descriptors.

Associated conformance descriptors are aliases that refer to associated
conformance requirements within a protocol descriptor’s list of
requirements. They will be used to provide protocol resilience against
the addition of new associated conformance requirements (which only makes 
sense for newly-introduced, defaulted associated types).

Author: DougGregor

include/swift/Demangling/DemangleNodes.def

@@ -210,6 +210,7 @@ NODE(CurryThunk)
 NODE(DispatchThunk)
 NODE(MethodDescriptor)
 NODE(ProtocolRequirementsBaseDescriptor)
+NODE(AssociatedConformanceDescriptor)
 NODE(AssociatedTypeDescriptor)
 NODE(ThrowsAnnotation)
 NODE(EmptyList)

include/swift/IRGen/Linking.h

@@ -206,6 +206,13 @@ class LinkEntity {
     /// The pointer is an AssociatedTypeDecl*.
     AssociatedTypeDescriptor,
 
+    /// An descriptor for an associated conformance within a protocol, which
+    /// will alias the TargetProtocolRequirement descripting this
+    /// particular associated conformance.
+    /// The pointer is a ProtocolDecl*; the index of the associated conformance
+    /// is stored in the data.
+    AssociatedConformanceDescriptor,
+
     /// A function which returns the default type metadata for the associated
     /// type of a protocol.  The secondary pointer is a ProtocolDecl*.
     /// The index of the associated type declaration is stored in the data.
@@ -342,6 +349,21 @@ class LinkEntity {
     Data = LINKENTITY_SET_FIELD(Kind, unsigned(kind));
   }
 
+  void setForProtocolAndAssociatedConformance(Kind kind,
+                                              const ProtocolDecl *proto,
+                                              CanType associatedType,
+                                              ProtocolDecl *associatedProtocol){
+    assert(isDeclKind(kind));
+    Pointer = static_cast<ValueDecl *>(const_cast<ProtocolDecl *>(proto));
+    SecondaryPointer = nullptr;
+    Data = LINKENTITY_SET_FIELD(Kind, unsigned(kind)) |
+           LINKENTITY_SET_FIELD(AssociatedConformanceIndex,
+                                getAssociatedConformanceIndex(
+                                                          proto,
+                                                          associatedType,
+                                                          associatedProtocol));
+  }
+
   void setForProtocolConformance(Kind kind, const ProtocolConformance *c) {
     assert(isProtocolConformanceKind(kind) && !isTypeKind(kind));
     Pointer = nullptr;
@@ -407,14 +429,12 @@ class LinkEntity {
   }
 
   // We store associated conformances using their index in the requirement
-  // list of the requirement signature of the conformance's protocol.
-  static unsigned getAssociatedConformanceIndex(
-                                      const ProtocolConformance *conformance,
+  // list of the requirement signature of the protocol.
+  static unsigned getAssociatedConformanceIndex(const ProtocolDecl *proto,
                                                 CanType associatedType,
                                                 ProtocolDecl *requirement) {
     unsigned index = 0;
-    for (const auto &reqt :
-           conformance->getProtocol()->getRequirementSignature()) {
+    for (const auto &reqt : proto->getRequirementSignature()) {
       if (reqt.getKind() == RequirementKind::Conformance &&
           reqt.getFirstType()->getCanonicalType() == associatedType &&
           reqt.getSecondType()->castTo<ProtocolType>()->getDecl() ==
@@ -426,15 +446,31 @@ class LinkEntity {
     llvm_unreachable("requirement not found in protocol");
   }
 
+  // We store associated conformances using their index in the requirement
+  // list of the requirement signature of the conformance's protocol.
+  static unsigned getAssociatedConformanceIndex(
+                                      const ProtocolConformance *conformance,
+                                      CanType associatedType,
+                                      ProtocolDecl *requirement) {
+    return getAssociatedConformanceIndex(conformance->getProtocol(),
+                                         associatedType, requirement);
+  }
+
   static std::pair<CanType, ProtocolDecl*>
-  getAssociatedConformanceByIndex(const ProtocolConformance *conformance,
+  getAssociatedConformanceByIndex(const ProtocolDecl *proto,
                                   unsigned index) {
-    auto &reqt = conformance->getProtocol()->getRequirementSignature()[index];
+    auto &reqt = proto->getRequirementSignature()[index];
     assert(reqt.getKind() == RequirementKind::Conformance);
     return { reqt.getFirstType()->getCanonicalType(),
              reqt.getSecondType()->castTo<ProtocolType>()->getDecl() };
   }
 
+  static std::pair<CanType, ProtocolDecl*>
+  getAssociatedConformanceByIndex(const ProtocolConformance *conformance,
+                                  unsigned index) {
+    return getAssociatedConformanceByIndex(conformance->getProtocol(), index);
+  }
+
   void setForType(Kind kind, CanType type) {
     assert(isTypeKind(kind));
     Pointer = type.getPointer();
@@ -758,6 +794,18 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity
+  forAssociatedConformanceDescriptor(ProtocolDecl *proto,
+                                     CanType associatedType,
+                                     ProtocolDecl *associatedProtocol) {
+    LinkEntity entity;
+    entity.setForProtocolAndAssociatedConformance(
+        Kind::AssociatedConformanceDescriptor,
+        proto, associatedType,
+        associatedProtocol);
+    return entity;
+  }
+
   static LinkEntity
   forAssociatedTypeMetadataAccessFunction(const ProtocolConformance *C,
                                           AssociatedType association) {
@@ -872,9 +920,15 @@ class LinkEntity {
   }
 
   std::pair<CanType, ProtocolDecl *> getAssociatedConformance() const {
-    assert(getKind() == Kind::AssociatedTypeWitnessTableAccessFunction);
-    return getAssociatedConformanceByIndex(getProtocolConformance(),
+    if (getKind() == Kind::AssociatedTypeWitnessTableAccessFunction) {
+      return getAssociatedConformanceByIndex(getProtocolConformance(),
                        LINKENTITY_GET_FIELD(Data, AssociatedConformanceIndex));
+    }
+
+    assert(getKind() == Kind::AssociatedConformanceDescriptor);
+    return getAssociatedConformanceByIndex(
+             cast<ProtocolDecl>(getDecl()),
+             LINKENTITY_GET_FIELD(Data, AssociatedConformanceIndex));
   }
 
   ProtocolDecl *getAssociatedProtocol() const {

lib/Demangling/Demangler.cpp

@@ -1827,6 +1827,14 @@ NodePointer Demangler::demangleThunkOrSpecialization() {
       return createWithChild(Node::Kind::DefaultAssociatedTypeMetadataAccessor,
                              popAssocTypeName());
 
+    case 'n': {
+      NodePointer requirementTy = popProtocol();
+      auto assocTypePath = popAssocTypePath();
+      NodePointer protoTy = popNode(Node::Kind::Type);
+      return createWithChildren(Node::Kind::AssociatedConformanceDescriptor,
+                                protoTy, assocTypePath, requirementTy);
+    }
+
     case 'H':
     case 'h': {
       auto nodeKind = c == 'H' ? Node::Kind::KeyPathEqualsThunkHelper

lib/Demangling/NodePrinter.cpp

@@ -308,6 +308,7 @@ class NodePrinter {
     case Node::Kind::ProtocolListWithClass:
     case Node::Kind::Allocator:
     case Node::Kind::ArgumentTuple:
+    case Node::Kind::AssociatedConformanceDescriptor:
     case Node::Kind::AssociatedTypeDescriptor:
     case Node::Kind::AssociatedTypeMetadataAccessor:
     case Node::Kind::AssociatedTypeWitnessTableAccessor:
@@ -1555,6 +1556,14 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << "lazy cache variable for type metadata for ";
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::AssociatedConformanceDescriptor:
+    Printer << "associated conformance descriptor for ";
+    print(Node->getChild(0));
+    Printer << ".";
+    print(Node->getChild(1));
+    Printer << ": ";
+    print(Node->getChild(2));
+    return nullptr;
   case Node::Kind::AssociatedTypeDescriptor:
     Printer << "associated type descriptor for ";
     print(Node->getChild(0));

lib/Demangling/OldRemangler.cpp

@@ -884,6 +884,10 @@ void Remangler::mangleAssociatedTypeDescriptor(Node *node) {
   Out << "<associated-type-descriptor>";
 }
 
+void Remangler::mangleAssociatedConformanceDescriptor(Node *node) {
+  Out << "<associated-conformance-descriptor>";
+}
+
 void Remangler::mangleAssociatedTypeMetadataAccessor(Node *node) {
   Out << "Wt";
   mangleChildNodes(node); // protocol conformance, identifier

lib/Demangling/Remangler.cpp

@@ -574,6 +574,11 @@ void Remangler::mangleAssociatedTypeDescriptor(Node *node) {
   Buffer << "Tl";
 }
 
+void Remangler::mangleAssociatedConformanceDescriptor(Node *node) {
+  mangleChildNodes(node);
+  Buffer << "Tn";
+}
+
 void Remangler::mangleAssociatedTypeMetadataAccessor(Node *node) {
   mangleChildNodes(node); // protocol conformance, identifier
   Buffer << "Wt";

lib/IRGen/GenDecl.cpp

@@ -3387,6 +3387,16 @@ llvm::GlobalValue *IRGenModule::defineAssociatedTypeDescriptor(
   return defineAlias(entity, definition);
 }
 
+llvm::GlobalValue *IRGenModule::defineAssociatedConformanceDescriptor(
+                                                ProtocolDecl *proto,
+                                                CanType subject,
+                                                ProtocolDecl *requirement,
+                                                llvm::Constant *definition) {
+  auto entity = LinkEntity::forAssociatedConformanceDescriptor(proto, subject,
+                                                               requirement);
+  return defineAlias(entity, definition);
+}
+
 llvm::Constant *IRGenModule::getAddrOfProtocolConformanceDescriptor(
                                 const NormalProtocolConformance *conformance,
                                 ConstantInit definition) {

lib/IRGen/GenMeta.cpp

@@ -709,6 +709,16 @@ namespace {
               B.getAddrOfCurrentPosition(IGM.ProtocolRequirementStructTy));
         }
 
+        if (entry.isAssociatedConformance()) {
+          // Define the associated conformance descriptor to point to the
+          // current position in the protocol descriptor.
+          IGM.defineAssociatedConformanceDescriptor(
+              Proto,
+              entry.getAssociatedConformancePath(),
+              entry.getAssociatedConformanceRequirement(),
+              B.getAddrOfCurrentPosition(IGM.ProtocolRequirementStructTy));
+        }
+
         auto reqt = B.beginStruct(IGM.ProtocolRequirementStructTy);
 
         auto info = getRequirementInfo(entry);

lib/IRGen/IRGenMangler.h

@@ -184,6 +184,19 @@ class IRGenMangler : public Mangle::ASTMangler {
     return finalize();
   }
 
+  std::string mangleAssociatedConformanceDescriptor(
+      const ProtocolDecl *proto,
+      CanType subject,
+      const ProtocolDecl *requirement) {
+    beginMangling();
+    appendAnyGenericType(proto);
+    bool isFirstAssociatedTypeIdentifier = true;
+    appendAssociatedTypePath(subject, isFirstAssociatedTypeIdentifier);
+    appendProtocolName(requirement);
+    appendOperator("Tn");
+    return finalize();
+  }
+
   std::string mangleProtocolConformanceDescriptor(
                                  const ProtocolConformance *Conformance) {
     beginMangling();
@@ -413,13 +426,6 @@ class IRGenMangler : public Mangle::ASTMangler {
 
   std::string manglePartialApplyForwarder(StringRef FuncName);
 
-  std::string mangleForProtocolDescriptor(ProtocolType *Proto) {
-    beginMangling();
-    appendProtocolName(Proto->getDecl(), /*allowStandardSubstitution=*/false);
-    appendOperator("P");
-    return finalize();
-  }
-
   std::string mangleTypeForForeignMetadataUniquing(Type type) {
     return mangleTypeWithoutPrefix(type);
   }

lib/IRGen/IRGenModule.h

@@ -1234,6 +1234,11 @@ private:                            \
   llvm::GlobalValue *defineAssociatedTypeDescriptor(
                                                   AssociatedTypeDecl *assocType,
                                                   llvm::Constant *definition);
+  llvm::GlobalValue *defineAssociatedConformanceDescriptor(
+                                                  ProtocolDecl *proto,
+                                                  CanType subject,
+                                                  ProtocolDecl *requirement,
+                                                  llvm::Constant *definition);
 
   llvm::Constant *getAddrOfProtocolDescriptor(ProtocolDecl *D,
                                       ConstantInit definition = ConstantInit());

lib/IRGen/Linking.cpp

@@ -179,6 +179,14 @@ std::string LinkEntity::mangleAsString() const {
     return mangler.mangleAssociatedTypeDescriptor(
                                           cast<AssociatedTypeDecl>(getDecl()));
 
+  case Kind::AssociatedConformanceDescriptor: {
+    auto assocConformance = getAssociatedConformance();
+    return mangler.mangleAssociatedConformanceDescriptor(
+             cast<ProtocolDecl>(getDecl()),
+             assocConformance.first,
+             assocConformance.second);
+  }
+
   case Kind::ProtocolConformanceDescriptor:
     return mangler.mangleProtocolConformanceDescriptor(
                    cast<NormalProtocolConformance>(getProtocolConformance()));
@@ -449,6 +457,7 @@ SILLinkage LinkEntity::getLinkage(ForDefinition_t forDefinition) const {
     return getSILLinkage(getDeclLinkage(getterDecl), forDefinition);
   }
 
+  case Kind::AssociatedConformanceDescriptor:
   case Kind::ObjCClass:
   case Kind::ObjCMetaclass:
   case Kind::SwiftMetaclassStub:
@@ -586,6 +595,7 @@ bool LinkEntity::isAvailableExternally(IRGenModule &IGM) const {
     // FIXME: Removing this triggers a linker bug
     return true;
 
+  case Kind::AssociatedConformanceDescriptor:
   case Kind::SwiftMetaclassStub:
   case Kind::ClassMetadataBaseOffset:
   case Kind::PropertyDescriptor:

lib/TBDGen/TBDGen.cpp

@@ -99,6 +99,15 @@ void TBDGenVisitor::addAssociatedTypeDescriptor(AssociatedTypeDecl *assocType) {
   addSymbol(entity);
 }
 
+void TBDGenVisitor::addAssociatedConformanceDescriptor(
+                                                 ProtocolDecl *proto,
+                                                 CanType subject,
+                                                 ProtocolDecl *requirement) {
+  auto entity = LinkEntity::forAssociatedConformanceDescriptor(proto, subject,
+                                                               requirement);
+  addSymbol(entity);
+}
+
 void TBDGenVisitor::addConformances(DeclContext *DC) {
   for (auto conformance : DC->getLocalConformances()) {
     auto protocol = conformance->getProtocol();
@@ -409,6 +418,20 @@ void TBDGenVisitor::visitProtocolDecl(ProtocolDecl *PD) {
     if (protocolDescriptorHasRequirements(PD))
       addProtocolRequirementsBaseDescriptor(PD);
 
+    for (const auto &req : PD->getRequirementSignature()) {
+      if (req.getKind() != RequirementKind::Conformance)
+        continue;
+
+      // Skip inherited requirements.
+      if (req.getFirstType()->isEqual(PD->getProtocolSelfType()))
+        continue;
+
+      addAssociatedConformanceDescriptor(
+          PD,
+          req.getFirstType()->getCanonicalType(),
+          req.getSecondType()->castTo<ProtocolType>()->getDecl());
+    }
+
     for (auto *member : PD->getMembers()) {
       if (PD->isResilient()) {
         if (auto *funcDecl = dyn_cast<AbstractFunctionDecl>(member)) {

lib/TBDGen/TBDGenVisitor.h

@@ -66,6 +66,9 @@ class TBDGenVisitor : public ASTVisitor<TBDGenVisitor> {
 
   void addProtocolRequirementsBaseDescriptor(ProtocolDecl *proto);
   void addAssociatedTypeDescriptor(AssociatedTypeDecl *assocType);
+  void addAssociatedConformanceDescriptor(ProtocolDecl *proto,
+                                          CanType subject,
+                                          ProtocolDecl *requirement);
 
 public:
   TBDGenVisitor(tapi::internal::InterfaceFile &symbols,

test/Demangle/Inputs/manglings.txt

@@ -331,3 +331,4 @@ $S2t21QP22ProtocolTypeAliasThingayAA4BlahV5SomeQa_GSgD ---> t2.Blah.SomeQ as t2.
 A.h<A>(A) -> ()inlined generic function <(A, A1)> of 
 $S1T19protocol_resilience17ResilientProtocolPTl --> associated type descriptor for T
 $S18resilient_protocol21ResilientBaseProtocolTL --> protocol requirements base descriptor for resilient_protocol.ResilientBaseProtocol
+$S1t1PP10AssocType2_AA1QTn --> associated conformance descriptor for t.P.AssocType2: t.Q

test/IRGen/protocol_resilience_descriptors.swift

@@ -20,15 +20,16 @@
 // Protocol requirements base descriptor
 // CHECK-DEFINITION: @"$S18resilient_protocol21ResilientBaseProtocolTL" ={{( dllexport)?}}{{( protected)?}} alias %swift.protocol_requirement, getelementptr (%swift.protocol_requirement, %swift.protocol_requirement* getelementptr inbounds (<{ i32, i32, i32, i32, i32, i32, %swift.protocol_requirement }>, <{ i32, i32, i32, i32, i32, i32, %swift.protocol_requirement }>* @"$S18resilient_protocol21ResilientBaseProtocolMp", i32 0, i32 6), i32 -1)
 
-// Associated type requirement aliases
+// Associated type and conformance
 
 // CHECK-DEFINITION: @"$S1T18resilient_protocol24ProtocolWithRequirementsPTl" ={{( dllexport)?}}{{( protected)?}} alias
+// CHECK-DEFINITION: @"$S18resilient_protocol29ProtocolWithAssocTypeDefaultsP2T2_AA014OtherResilientC0Tn" ={{( dllexport)?}}{{( protected)?}} alias
 
 // Default associated type witnesses
 // CHECK-DEFINITION-LABEL: define internal swiftcc %swift.metadata_response @"$S2T118resilient_protocol29ProtocolWithAssocTypeDefaultsPTM"
 
 // CHECK-DEFINITION-LABEL: define internal swiftcc %swift.metadata_response @"$S2T218resilient_protocol29ProtocolWithAssocTypeDefaultsPTM"
-// CHECK-DEFINITION: getelementptr inbounds i8*, i8** [[WTABLE:%.*]], i32 1
+// CHECK-DEFINITION: getelementptr inbounds i8*, i8** [[WTABLE:%.*]], i32 2
 // CHECK-DEFINITION: call{{.*}}S18resilient_protocol7WrapperVMa
 
 import resilient_protocol

test/Inputs/resilient_protocol.swift

@@ -28,9 +28,9 @@ public protocol ProtocolWithRequirements {
   func second()
 }
 
-public struct Wrapper<T> { }
+public struct Wrapper<T>: OtherResilientProtocol { }
 
 public protocol ProtocolWithAssocTypeDefaults {
   associatedtype T1 = Self
-  associatedtype T2 = Wrapper<T1>
+  associatedtype T2: OtherResilientProtocol = Wrapper<T1>
 }