[Mangling] Separate mangling for associated/base conformance accessors.

It’s simpler to use separate manglings for these two cases.

(cherry picked from commit 735a83b)

Author: DougGregor

docs/ABI/Mangling.rst

@@ -147,7 +147,7 @@ Globals
 
   global ::= protocol-conformance identifier 'Wt' // associated type metadata accessor (HISTORICAL)
   global ::= protocol-conformance assoc-type-list protocol 'WT' // associated type witness table accessor
-  global ::= protocol-conformance type protocol 'WT' // inherited protocol witness table accessor
+  global ::= protocol-conformance protocol 'Wb' // base protocol witness table accessor
   global ::= type protocol-conformance 'Wl' // lazy protocol witness table accessor
 
   global ::= type 'WV'                   // value witness table

include/swift/Demangling/DemangleNodes.def

@@ -33,6 +33,7 @@ NODE(AssociatedTypeRef)
 NODE(AssociatedTypeMetadataAccessor)
 NODE(DefaultAssociatedTypeMetadataAccessor)
 NODE(AssociatedTypeWitnessTableAccessor)
+NODE(BaseWitnessTableAccessor)
 NODE(AutoClosureType)
 NODE(BoundGenericClass)
 NODE(BoundGenericEnum)

include/swift/Demangling/Demangler.h

@@ -455,7 +455,6 @@ class Demangler : public NodeFactory {
 
   NodePointer popAssocTypeName();
   NodePointer popAssocTypePath();
-  NodePointer popSelfOrAssocTypePath();
   NodePointer getDependentGenericParamType(int depth, int index);
   NodePointer demangleGenericParamIndex();
   NodePointer popProtocolConformance();

lib/Demangling/Context.cpp

@@ -162,6 +162,7 @@ bool Context::hasSwiftCallingConvention(llvm::StringRef MangledName) {
     case Node::Kind::LazyProtocolWitnessTableAccessor:
     case Node::Kind::AssociatedTypeMetadataAccessor:
     case Node::Kind::AssociatedTypeWitnessTableAccessor:
+    case Node::Kind::BaseWitnessTableAccessor:
     case Node::Kind::ObjCAttribute:
       return false;
     default:

lib/Demangling/Demangler.cpp

@@ -1875,20 +1875,6 @@ NodePointer Demangler::popAssocTypePath() {
   return AssocTypePath;
 }
 
-NodePointer Demangler::popSelfOrAssocTypePath() {
-  if (auto Type = popNode(Node::Kind::Type)) {
-    if (Type->getChild(0) &&
-        Type->getChild(0)->getKind() ==
-        Node::Kind::DependentGenericParamType) {
-      return Type;
-    }
-
-    pushNode(Type);
-  }
-
-  return popAssocTypePath();
-}
-
 NodePointer Demangler::getDependentGenericParamType(int depth, int index) {
   if (depth < 0 || index < 0)
     return nullptr;
@@ -2444,11 +2430,17 @@ NodePointer Demangler::demangleWitness() {
     }
     case 'T': {
       NodePointer ProtoTy = popNode(Node::Kind::Type);
-      NodePointer ConformingType = popSelfOrAssocTypePath();
+      NodePointer ConformingType = popAssocTypePath();
       NodePointer Conf = popProtocolConformance();
       return createWithChildren(Node::Kind::AssociatedTypeWitnessTableAccessor,
                                 Conf, ConformingType, ProtoTy);
     }
+    case 'b': {
+      NodePointer ProtoTy = popNode(Node::Kind::Type);
+      NodePointer Conf = popProtocolConformance();
+      return createWithChildren(Node::Kind::BaseWitnessTableAccessor,
+                                Conf, ProtoTy);
+    }
     case 'O': {
       switch (nextChar()) {
       case 'y': {

lib/Demangling/NodePrinter.cpp

@@ -320,6 +320,7 @@ class NodePrinter {
     case Node::Kind::AssociatedTypeWitnessTableAccessor:
     case Node::Kind::AutoClosureType:
     case Node::Kind::BaseConformanceDescriptor:
+    case Node::Kind::BaseWitnessTableAccessor:
     case Node::Kind::ClassMetadataBaseOffset:
     case Node::Kind::CFunctionPointer:
     case Node::Kind::Constructor:
@@ -1656,6 +1657,12 @@ NodePointer NodePrinter::print(NodePointer Node, bool asPrefixContext) {
     Printer << " in ";
     print(Node->getChild(0));
     return nullptr;
+  case Node::Kind::BaseWitnessTableAccessor:
+    Printer << "base witness table accessor for ";
+    print(Node->getChild(1));
+    Printer << " in ";
+    print(Node->getChild(0));
+    return nullptr;
   case Node::Kind::ClassMetadataBaseOffset:
     Printer << "class metadata base offset for ";
     print(Node->getChild(0));

lib/Demangling/OldRemangler.cpp

@@ -963,6 +963,10 @@ void Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node) {
   mangleProtocolWithoutPrefix(node->begin()[2]); // type
 }
 
+void Remangler::mangleBaseWitnessTableAccessor(Node *node) {
+  Out << "<base-witness-table-accessor>";
+}
+
 void Remangler::mangleReabstractionThunkHelper(Node *node) {
   Out << "TR";
   if (node->getNumChildren() == 3) Out << 'G';

lib/Demangling/Remangler.cpp

@@ -605,6 +605,11 @@ void Remangler::mangleAssociatedTypeWitnessTableAccessor(Node *node) {
   Buffer << "WT";
 }
 
+void Remangler::mangleBaseWitnessTableAccessor(Node *node) {
+  mangleChildNodes(node); // protocol conformance, protocol
+  Buffer << "Wb";
+}
+
 void Remangler::mangleAutoClosureType(Node *node) {
   mangleChildNodesReversed(node); // argument tuple, result type
   Buffer << "XK";

lib/IRGen/IRGenMangler.h

@@ -280,17 +280,23 @@ class IRGenMangler : public Mangle::ASTMangler {
                                       const ProtocolDecl *Proto) {
     beginMangling();
     appendProtocolConformance(Conformance);
-    if (isa<GenericTypeParamType>(AssociatedType)) {
-      appendType(AssociatedType);
-    } else {
-      bool isFirstAssociatedTypeIdentifier = true;
-      appendAssociatedTypePath(AssociatedType, isFirstAssociatedTypeIdentifier);
-    }
+    bool isFirstAssociatedTypeIdentifier = true;
+    appendAssociatedTypePath(AssociatedType, isFirstAssociatedTypeIdentifier);
     appendAnyGenericType(Proto);
     appendOperator("WT");
     return finalize();
   }
 
+  std::string mangleBaseWitnessTableAccessFunction(
+                                      const ProtocolConformance *Conformance,
+                                      const ProtocolDecl *BaseProto) {
+    beginMangling();
+    appendProtocolConformance(Conformance);
+    appendAnyGenericType(BaseProto);
+    appendOperator("Wb");
+    return finalize();
+  }
+
   void appendAssociatedTypePath(CanType associatedType, bool &isFirst) {
     if (auto memberType = dyn_cast<DependentMemberType>(associatedType)) {
       appendAssociatedTypePath(memberType.getBase(), isFirst);

lib/IRGen/Linking.cpp

@@ -247,6 +247,11 @@ std::string LinkEntity::mangleAsString() const {
 
   case Kind::AssociatedTypeWitnessTableAccessFunction: {
     auto assocConf = getAssociatedConformance();
+    if (isa<GenericTypeParamType>(assocConf.first)) {
+      return mangler.mangleBaseWitnessTableAccessFunction(
+                  getProtocolConformance(), assocConf.second);
+    }
+    
     return mangler.mangleAssociatedTypeWitnessTableAccessFunction(
                 getProtocolConformance(), assocConf.first, assocConf.second);
   }