[ABI] Record unmangled names in Swift protocol descriptors.

Rather than storing a mangled name in a Swift protocol descriptor,
which encodes information that is redundant with the context of the
protocol, store an unmangled name as in nominal type descriptors. Update
the various places where this name is used to extract the demangle
tree from the context descriptors.

Author: DougGregor

docs/ABI/TypeMetadata.rst

@@ -427,8 +427,7 @@ as follows:
   * **Bit 1** indicates that the protocol is **resilient**.
   * **Bits 2-7** indicate specify the **special protocol kind**. Only one
     special protocol kind is defined: the `Error` protocol has value 1.    
-- A pointer to the **name** of the protocol. FIXME: The name is currently
-  mangles, but will change to the (unmangled) name.
+- A pointer to the **name** of the protocol.
 - The number of generic requirements within the **requirement signature** of
   the protocol. The generic requirements themselves follow the fixed part
   of the protocol descriptor.

include/swift/Remote/MetadataReader.h

@@ -383,28 +383,9 @@ class MetadataReader {
         }
 #endif
 
-        // Read the protocol descriptor.
-        ContextDescriptorRef descriptor
-          = readContextDescriptor(ProtocolAddress.getSwiftProtocol());
-        if (!descriptor)
-          return BuiltType();
-
-        auto protocolBuffer =
-          reinterpret_cast<const TargetProtocolDescriptor<Runtime> *>
-            (descriptor.getLocalBuffer());
-
-        std::string mangledNameStr;
-        auto nameAddress = resolveRelativeField(descriptor,
-                                                protocolBuffer->Name);
-        if (!Reader->readString(RemoteAddress(nameAddress),
-                                mangledNameStr))
-          return BuiltType();
-
-        StringRef mangledName =
-          Demangle::dropSwiftManglingPrefix(mangledNameStr);
-
-        Demangle::Context DCtx;
-        auto Demangled = DCtx.demangleTypeAsNode(mangledName);
+        Demangle::Demangler Dem;
+        auto Demangled = readDemanglingForContextDescriptor(
+            ProtocolAddress.getSwiftProtocol(), Dem);
         if (!Demangled)
           return BuiltType();
 
@@ -1218,7 +1199,17 @@ class MetadataReader {
         nodeKind = Demangle::Node::Kind::Enum;
         isTypeContext = true;
         break;
+      case ContextDescriptorKind::Protocol: {
+        auto protocolBuffer =
+          reinterpret_cast<const TargetProtocolDescriptor<Runtime> *>
+            (parent.getLocalBuffer());
+        auto nameAddress = resolveRelativeField(parent, protocolBuffer->Name);
+        if (!Reader->readString(RemoteAddress(nameAddress), nodeName))
+          return nullptr;
 
+        nodeKind = Demangle::Node::Kind::Protocol;
+        break;
+      }
       case ContextDescriptorKind::Extension:
         // TODO: Remangle something about the extension context here.
         return nullptr;

lib/IRGen/GenMeta.cpp

@@ -514,15 +514,7 @@ namespace {
     }
 
     void addName() {
-      // Include the _Tt prefix. The runtime is currently depending on this
-      // so the naming scheme matches up with @objc protocols.
-      // FIXME: We want to put the bare name here, because the context
-      // information is enough for us.
-      IRGenMangler mangler;
-      std::string Name =
-        mangler.mangleForProtocolDescriptor(Proto->getDeclaredType());
-
-      auto nameStr = IGM.getAddrOfGlobalString(Name,
+      auto nameStr = IGM.getAddrOfGlobalString(Proto->getName().str(),
                                            /*willBeRelativelyAddressed*/ true);
       B.addRelativeAddress(nameStr);
     }

stdlib/public/runtime/Demangle.cpp

@@ -122,6 +122,19 @@ swift::_buildDemanglingForContext(const ContextDescriptor *context,
       break;
     }
 
+    case ContextDescriptorKind::Protocol: {
+      auto protocol = llvm::cast<ProtocolDescriptor>(component);
+      auto name = protocol->Name.get();
+
+      auto protocolNode = Dem.createNode(Node::Kind::Protocol);
+      protocolNode->addChild(node, Dem);
+      auto nameNode = Dem.createNode(Node::Kind::Identifier, name);
+      protocolNode->addChild(nameNode, Dem);
+
+      node = protocolNode;
+      break;
+    }
+
     default:
       // Form a type context demangling for type contexts.
       if (auto type = llvm::dyn_cast<TypeContextDescriptor>(component)) {
@@ -392,37 +405,51 @@ swift::_swift_buildDemanglingForMetadata(const Metadata *type,
     // its canonical ordering of protocols.
 
     for (auto protocol : protocols) {
-      // The protocol name is mangled as a type symbol, with the _Tt prefix.
-      StringRef ProtoName(protocol.getName());
-      NodePointer protocolNode = Dem.demangleSymbol(ProtoName);
-
-      // ObjC protocol names aren't mangled.
-      if (!protocolNode) {
-        auto module = Dem.createNode(Node::Kind::Module,
-                                          MANGLING_MODULE_OBJC);
-        auto node = Dem.createNode(Node::Kind::Protocol);
-        node->addChild(module, Dem);
-        node->addChild(Dem.createNode(Node::Kind::Identifier, ProtoName), Dem);
-        auto typeNode = Dem.createNode(Node::Kind::Type);
-        typeNode->addChild(node, Dem);
-        type_list->addChild(typeNode, Dem);
+#if SWIFT_OBJC_INTEROP
+      if (protocol.isObjC()) {
+        // The protocol name is mangled as a type symbol, with the _Tt prefix.
+        StringRef ProtoName(protocol.getName());
+        NodePointer protocolNode = Dem.demangleSymbol(ProtoName);
+
+        // ObjC protocol names aren't mangled.
+        if (!protocolNode) {
+          auto module = Dem.createNode(Node::Kind::Module,
+                                            MANGLING_MODULE_OBJC);
+          auto node = Dem.createNode(Node::Kind::Protocol);
+          node->addChild(module, Dem);
+          node->addChild(Dem.createNode(Node::Kind::Identifier, ProtoName),
+                         Dem);
+          auto typeNode = Dem.createNode(Node::Kind::Type);
+          typeNode->addChild(node, Dem);
+          type_list->addChild(typeNode, Dem);
+          continue;
+        }
+
+        // Dig out the protocol node.
+        // Global -> (Protocol|TypeMangling)
+        protocolNode = protocolNode->getChild(0);
+        if (protocolNode->getKind() == Node::Kind::TypeMangling) {
+          protocolNode = protocolNode->getChild(0); // TypeMangling -> Type
+          protocolNode = protocolNode->getChild(0); // Type -> ProtocolList
+          protocolNode = protocolNode->getChild(0); // ProtocolList -> TypeList
+          protocolNode = protocolNode->getChild(0); // TypeList -> Type
+
+          assert(protocolNode->getKind() == Node::Kind::Type);
+          assert(protocolNode->getChild(0)->getKind() == Node::Kind::Protocol);
+        } else {
+          assert(protocolNode->getKind() == Node::Kind::Protocol);
+        }
+
+        type_list->addChild(protocolNode, Dem);
         continue;
       }
+#endif
 
-      // Dig out the protocol node.
-      // Global -> (Protocol|TypeMangling)
-      protocolNode = protocolNode->getChild(0);
-      if (protocolNode->getKind() == Node::Kind::TypeMangling) {
-        protocolNode = protocolNode->getChild(0); // TypeMangling -> Type
-        protocolNode = protocolNode->getChild(0); // Type -> ProtocolList
-        protocolNode = protocolNode->getChild(0); // ProtocolList -> TypeList
-        protocolNode = protocolNode->getChild(0); // TypeList -> Type
-
-        assert(protocolNode->getKind() == Node::Kind::Type);
-        assert(protocolNode->getChild(0)->getKind() == Node::Kind::Protocol);
-      } else {
-        assert(protocolNode->getKind() == Node::Kind::Protocol);
-      }
+      auto protocolNode =
+          _buildDemanglingForContext(protocol.getSwiftProtocol(), { }, false,
+                                     Dem);
+      if (!protocolNode)
+        return nullptr;
 
       type_list->addChild(protocolNode, Dem);
     }

stdlib/public/runtime/MetadataLookup.cpp

@@ -233,7 +233,19 @@ swift::_contextDescriptorMatchesMangling(const ContextDescriptor *context,
       node = node->getChild(0);
       break;
     }
-    
+
+    case ContextDescriptorKind::Protocol:
+      // Match a protocol context.
+      if (node->getKind() == Demangle::Node::Kind::Protocol) {
+        auto proto = llvm::cast<ProtocolDescriptor>(context);
+        auto nameNode = node->getChild(1);
+        if (nameNode->getText() == proto->Name.get()) {
+          node = node->getChild(0);
+          break;
+        }
+      }
+      return false;
+
     default:
       if (auto type = llvm::dyn_cast<TypeContextDescriptor>(context)) {
         switch (node->getKind()) {
@@ -290,7 +302,7 @@ swift::_contextDescriptorMatchesMangling(const ContextDescriptor *context,
         return false;
 
       }
-      
+
       // We don't know about this kind of context, or it doesn't have a stable
       // name we can match to.
       return false;
@@ -445,16 +457,11 @@ void swift::swift_registerProtocols(const ProtocolRecord *begin,
 
 static const ProtocolDescriptor *
 _searchProtocolRecords(ProtocolMetadataPrivateState &C,
-                       const llvm::StringRef protocolName){
+                       const Demangle::NodePointer &node) {
   for (auto &section : C.SectionsToScan.snapshot()) {
     for (const auto &record : section) {
       if (auto protocol = record.Protocol.getPointer()) {
-        // Drop the "S$" prefix from the protocol record. It's not used in
-        // the type itself.
-        StringRef foundProtocolName = protocol->Name.get();
-        assert(foundProtocolName.startswith("$S"));
-        foundProtocolName = foundProtocolName.drop_front(2);
-        if (foundProtocolName == protocolName)
+        if (_contextDescriptorMatchesMangling(protocol, node))
           return protocol;
       }
     }
@@ -464,17 +471,35 @@ _searchProtocolRecords(ProtocolMetadataPrivateState &C,
 }
 
 static const ProtocolDescriptor *
-_findProtocolDescriptor(llvm::StringRef mangledName) {
+_findProtocolDescriptor(const Demangle::NodePointer &node,
+                        Demangle::Demangler &Dem,
+                        std::string &mangledName) {
   const ProtocolDescriptor *foundProtocol = nullptr;
   auto &T = Protocols.get();
 
+  // If we have a symbolic reference to a context, resolve it immediately.
+  NodePointer symbolicNode = node;
+  if (symbolicNode->getKind() == Node::Kind::Type)
+    symbolicNode = symbolicNode->getChild(0);
+  if (symbolicNode->getKind() == Node::Kind::SymbolicReference)
+    return cast<ProtocolDescriptor>(
+      (const ContextDescriptor *)symbolicNode->getIndex());
+
+  mangledName =
+    Demangle::mangleNode(node,
+                         [&](const void *context) -> NodePointer {
+                           return _buildDemanglingForContext(
+                               (const ContextDescriptor *) context,
+                               {}, false, Dem);
+                         });
+
   // Look for an existing entry.
   // Find the bucket for the metadata entry.
   if (auto Value = T.ProtocolCache.find(mangledName))
     return Value->getDescription();
 
   // Check type metadata records
-  foundProtocol = _searchProtocolRecords(T, mangledName);
+  foundProtocol = _searchProtocolRecords(T, node);
 
   if (foundProtocol) {
     T.ProtocolCache.getOrInsert(mangledName, foundProtocol);
@@ -761,11 +786,10 @@ class DecodedMetadataBuilder {
     }
 #endif
 
-    auto mangledName = Demangle::mangleNode(node);
-
-    // Look for a Swift protocol with this mangled name.
-    if (auto protocol = _findProtocolDescriptor(mangledName))
-      return ProtocolDescriptorRef::forSwift(protocol);
+    // Look for a protocol descriptor based on its mangled name.
+    std::string mangledName;
+    if (auto protocol = _findProtocolDescriptor(node, demangler, mangledName))
+      return ProtocolDescriptorRef::forSwift(protocol);;
 
 #if SWIFT_OBJC_INTEROP
     // Look for a Swift-defined @objc protocol with the Swift 3 mangling that

test/IRGen/protocol_metadata.swift

@@ -25,7 +25,7 @@ protocol ABO : A, B, O { func abo() }
 // CHECK-SAME: @_PROTOCOL_METHOD_TYPES__TtP17protocol_metadata1O_
 // CHECK-SAME: }
 
-// CHECK: [[A_NAME:@.*]] = private constant [25 x i8] c"$S17protocol_metadata1AP\00"
+// CHECK: [[A_NAME:@.*]] = private constant [2 x i8] c"A\00"
 
 // CHECK-LABEL: @"$S17protocol_metadata1AMp" = hidden constant
 // CHECK-SAME:   i32 65603,
@@ -36,7 +36,7 @@ protocol ABO : A, B, O { func abo() }
 // CHECK-SAME:   i32 0,
 // CHECK-SAME: }
 
-// CHECK: [[B_NAME:@.*]] = private constant [25 x i8] c"$S17protocol_metadata1BP\00"
+// CHECK: [[B_NAME:@.*]] = private constant [2 x i8] c"B\00"
 // CHECK-LABEL: @"$S17protocol_metadata1BMp" = hidden constant
 // CHECK-SAME:   i32 65603,
 // CHECK-SAME:   @"$S17protocol_metadataMXM"
@@ -45,7 +45,7 @@ protocol ABO : A, B, O { func abo() }
 // CHECK-SAME:   i32 1,
 // CHECK: }
 
-// CHECK: [[C_NAME:@.*]] = private constant [25 x i8] c"$S17protocol_metadata1CP\00"
+// CHECK: [[C_NAME:@.*]] = private constant [2 x i8] c"C\00"
 // CHECK-LABEL: @"$S17protocol_metadata1CMp" = hidden constant
 // CHECK-SAME:   i32 67,
 // CHECK-SAME:   @"$S17protocol_metadataMXM"
@@ -68,7 +68,7 @@ protocol ABO : A, B, O { func abo() }
 
 // -- inheritance lists for refined protocols
 
-// CHECK: [[AB_NAME:@.*]] = private constant [26 x i8] c"$S17protocol_metadata2ABP\00"
+// CHECK: [[AB_NAME:@.*]] = private constant [3 x i8] c"AB\00"
 // CHECK: @"$S17protocol_metadata2ABMp" = hidden constant
 // CHECK-SAME:   i32 65603,
 // CHECK-SAME:   @"$S17protocol_metadataMXM"

test/IRGen/protocol_resilience.sil

@@ -39,7 +39,7 @@ import resilient_protocol
 // CHECK-SAME: }
 
 // Protocol descriptor for ResilientProtocol
-// CHECK: [[RESILIENT_PROTOCOL_NAME:@.*]] = private constant [44 x i8] c"$S19protocol_resilience17ResilientProtocolP\00
+// CHECK: [[RESILIENT_PROTOCOL_NAME:@.*]] = private constant [18 x i8] c"ResilientProtocol\00
 // CHECK: [[ASSOCIATED_TYPES_T:@.*]] = private constant [2 x i8] c"T\00"
 // CHECK: @"$S19protocol_resilience17ResilientProtocolMp" = {{(dllexport )?}}{{(protected )?}}constant
 // CHECK-SAME:   i32 196675,

test/IRGen/special_protocols.sil

@@ -1,7 +1,7 @@
 // RUN: %target-swift-frontend -assume-parsing-unqualified-ownership-sil %s -emit-ir -parse-stdlib -module-name Swift | %FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-%target-ptrsize
 
 public protocol Error {}
-// CHECK: [[ERROR_NAME:@.*]] = private constant [11 x i8] c"$Ss5ErrorP\00"
+// CHECK: [[ERROR_NAME:@.*]] = private constant [6 x i8] c"Error\00"
 
 // CHECK-LABEL: @"$Ss5ErrorMp" = {{(dllexport )?}}{{(protected )?}}constant
 // --                 0x0000_0047: special protocol 01, non-class, unique, protocol context