Mangling support for extended existential type shapes

rjmccall · rjmccall · commit 7c66e7fafa76 · 2022-04-12T19:58:14.000-04:00
diff --git a/docs/ABI/Mangling.rst b/docs/ABI/Mangling.rst
@@ -189,6 +189,8 @@ Globals
   global ::= global 'MN'                 // noncanonical specialized generic type metadata for global
   global ::= global 'Mz'                 // canonical specialized generic type metadata caching token
 
+  global ::= global 'Mq'                 // global with a uniquing prefix
+
   #if SWIFT_RUNTIME_VERSION >= 5.4
     global ::= context (decl-name '_')+ 'WZ' // global variable one-time initialization function
     global ::= context (decl-name '_')+ 'Wz' // global variable one-time initialization token
@@ -914,6 +916,23 @@ than the module of the conforming type or the conformed-to protocol), it is
 mangled with its offset into the set of conformance requirements, the
 root protocol conformance, and the suffix 'g'.
 
+::
+
+  // No generalization signature, no type expression.
+  extended-existential-shape ::= generic-signature 'Xg' extended-existential-value-storage
+
+  // Generalization signature (the second one), no type expression.
+  extended-existential-shape ::= generic-signature generic-signature 'XG' extended-existential-value-storage
+
+  // No generalization signature, type expression.
+  extended-existential-shape ::= generic-signature type 'Xh' extended-existential-value-storage
+
+  // Generalization signature (the second one), type expression.
+  extended-existential-shape ::= generic-signature generic-signature type 'Xh' extended-existential-value-storage
+
+  extended-existential-value-storage ::= 'o' // opaque
+  extended-existential-value-storage ::= 'c' // class
+  extended-existential-value-storage ::= 'm' // metatype
 
 Identifiers
 ~~~~~~~~~~~
diff --git a/include/swift/Demangling/DemangleNodes.def b/include/swift/Demangling/DemangleNodes.def
@@ -335,6 +335,9 @@ NODE(CompileTimeConst)
 NODE(OpaqueReturnTypeIndexed)
 NODE(BackDeploymentThunk)
 NODE(BackDeploymentFallback)
+NODE(ExtendedExistentialTypeShape)
+NODE(ExtendedExistentialValueStorage)
+NODE(Uniquable)
 
 #undef CONTEXT_NODE
 #undef NODE
diff --git a/include/swift/Demangling/Demangler.h b/include/swift/Demangling/Demangler.h
@@ -529,6 +529,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleArchetype();
   NodePointer demangleAssociatedTypeSimple(NodePointer GenericParamIdx);
   NodePointer demangleAssociatedTypeCompound(NodePointer GenericParamIdx);
+  NodePointer demangleExtendedExistentialShape(char kind);
 
   NodePointer popAssocTypeName();
   NodePointer popAssocTypePath();
diff --git a/lib/Demangling/Demangler.cpp b/lib/Demangling/Demangler.cpp
@@ -2117,6 +2117,8 @@ NodePointer Demangler::demangleMetatype() {
       return createWithChild(Node::Kind::ProtocolDescriptor, popProtocol());
     case 'P':
       return createWithPoppedType(Node::Kind::GenericTypeMetadataPattern);
+    case 'q':
+      return createWithChild(Node::Kind::Uniquable, popNode());
     case 'Q':
       return createWithChild(Node::Kind::OpaqueTypeDescriptor, popNode());
     case 'r':
@@ -3227,6 +3229,11 @@ NodePointer Demangler::demangleSpecialType() {
       return popFunctionType(Node::Kind::ObjCBlock);
     case 'C':
       return popFunctionType(Node::Kind::CFunctionPointer);
+    case 'g':
+    case 'G':
+    case 'h':
+    case 'H':
+      return demangleExtendedExistentialShape(specialChar);
     case 'z':
       switch (auto cchar = nextChar()) {
       case 'B':
@@ -3374,6 +3381,51 @@ NodePointer Demangler::demangleSpecialType() {
   }
 }
 
+NodePointer Demangler::demangleExtendedExistentialShape(char nodeKind) {
+  assert(nodeKind == 'g' || nodeKind == 'G' ||
+         nodeKind == 'h' || nodeKind == 'H');
+
+  NodePointer type = nullptr;
+  if (nodeKind == 'h' || nodeKind == 'H')
+    type = popNode(Node::Kind::Type);
+
+  NodePointer genSig = nullptr;
+  if (nodeKind == 'G' || nodeKind == 'H')
+    genSig = popNode(Node::Kind::DependentGenericSignature);
+
+  NodePointer reqSig = popNode(Node::Kind::DependentGenericSignature);
+
+  NodePointer valueStorage = [&]() -> NodePointer {
+    switch (nextChar()) {
+    case 'o':
+      return createNode(Node::Kind::ExtendedExistentialValueStorage,
+                        "opaque");
+    case 'c':
+      return createNode(Node::Kind::ExtendedExistentialValueStorage,
+                        "class");
+    case 'm':
+      return createNode(Node::Kind::ExtendedExistentialValueStorage,
+                        "metatype");
+    default:
+      return nullptr;
+    }
+  }();
+  if (!valueStorage) return nullptr;
+
+  // Make a default type expression if one wasn't given.
+  if (!type) {
+    type = createType(getDependentGenericParamType(genSig ? 1 : 0, 0));
+  }
+
+  if (genSig) {
+    return createWithChildren(Node::Kind::ExtendedExistentialTypeShape,
+                              reqSig, genSig, type, valueStorage);
+  } else {
+    return createWithChildren(Node::Kind::ExtendedExistentialTypeShape,
+                              reqSig, type, valueStorage);
+  }
+}
+
 NodePointer Demangler::demangleMetatypeRepresentation() {
   switch (nextChar()) {
     case 't':
diff --git a/lib/Demangling/NodePrinter.cpp b/lib/Demangling/NodePrinter.cpp
@@ -594,6 +594,9 @@ class NodePrinter {
     case Node::Kind::AccessibleFunctionRecord:
     case Node::Kind::BackDeploymentThunk:
     case Node::Kind::BackDeploymentFallback:
+    case Node::Kind::ExtendedExistentialTypeShape:
+    case Node::Kind::ExtendedExistentialValueStorage:
+    case Node::Kind::Uniquable:
       return false;
     }
     printer_unreachable("bad node kind");
@@ -2962,6 +2965,41 @@ NodePointer NodePrinter::print(NodePointer Node, unsigned depth,
       Printer << " suspend resume partial function for ";
     }
     return nullptr;
+  case Node::Kind::Uniquable:
+    Printer << "uniquable ";
+    print(Node->getChild(0), depth + 1);
+    return nullptr;
+  case Node::Kind::ExtendedExistentialTypeShape: {
+    // Printing the requirement signature is pretty useless if we
+    // don't print `where` clauses.
+    auto savedDisplayWhereClauses = Options.DisplayWhereClauses;
+    Options.DisplayWhereClauses = true;
+
+    NodePointer reqSig = Node->getChild(0);
+    NodePointer genSig = nullptr, type = nullptr;
+    if (Node->getNumChildren() == 4) {
+      genSig = Node->getChild(1);
+      type = Node->getChild(2);
+    } else {
+      type = Node->getChild(1);
+    }
+
+    Printer << "existential shape for ";
+    if (genSig) {
+      print(genSig, depth + 1);
+      Printer << " ";
+    }
+    Printer << "any";
+    print(reqSig, depth + 1);
+    Printer << " ";
+    print(type, depth + 1);
+
+    Options.DisplayWhereClauses = savedDisplayWhereClauses;
+    return nullptr;
+  }
+  case Node::Kind::ExtendedExistentialValueStorage:
+    Printer << Node->getText();
+    return nullptr;
   }
 
   printer_unreachable("bad node kind!");
diff --git a/lib/Demangling/OldRemangler.cpp b/lib/Demangling/OldRemangler.cpp
@@ -2718,6 +2718,17 @@ ManglingError Remangler::mangleParameterizedProtocol(Node *node,
                                                      unsigned int depth) {
   return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
 }
+ManglingError Remangler::mangleUniquable(Node *node, unsigned int depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+ManglingError Remangler::mangleExtendedExistentialTypeShape(Node *node,
+                                                     unsigned int depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
+ManglingError Remangler::mangleExtendedExistentialValueStorage(Node *node,
+                                                     unsigned int depth) {
+  return MANGLING_ERROR(ManglingError::UnsupportedNodeKind, node);
+}
 ManglingError
 Remangler::mangleCanonicalSpecializedGenericMetaclass(Node *node,
                                                       unsigned depth) {
diff --git a/lib/Demangling/Remangler.cpp b/lib/Demangling/Remangler.cpp
@@ -3437,6 +3437,76 @@ ManglingError Remangler::mangleBackDeploymentFallback(Node *node,
   return ManglingError::Success;
 }
 
+ManglingError Remangler::mangleUniquable(Node *node, unsigned depth) {
+  RETURN_IF_ERROR(mangle(node->getChild(0), depth + 1));
+  Buffer << "Mq";
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleExtendedExistentialTypeShape(Node *node,
+                                                            unsigned depth) {
+  NodePointer reqSig, genSig, type, storage;
+  reqSig = node->getChild(0);
+  if (node->getNumChildren() == 3) {
+    genSig = nullptr;
+    type = node->getChild(1);
+    storage = node->getChild(2);
+  } else {
+    genSig = node->getChild(1);
+    type = node->getChild(2);
+    storage = node->getChild(3);
+  }
+
+  RETURN_IF_ERROR(mangle(reqSig, depth + 1));
+  if (genSig) {
+    RETURN_IF_ERROR(mangle(genSig, depth + 1));  
+  }
+
+  // Recognize the special case of a type expression that's just the
+  // unique requirement type parameter.
+  {
+    if (type->getKind() != Node::Kind::Type)
+      return MANGLING_ERROR(ManglingError::WrongNodeType, type);
+    auto typeNode = type->getChild(0);
+
+    if (typeNode->getKind() == Node::Kind::DependentGenericParamType) {
+      auto paramDepth = typeNode->getChild(0)->getIndex();
+      auto index = typeNode->getChild(1)->getIndex();
+      if (paramDepth == (genSig ? 1 : 0) && index == 0)
+        type = nullptr;
+    }
+  }
+  if (type)
+    RETURN_IF_ERROR(mangle(type, depth + 1));
+
+  if (genSig && type)
+    Buffer << "XH";
+  else if (type)
+    Buffer << "Xh";
+  else if (genSig)
+    Buffer << "XG";
+  else
+    Buffer << "Xg";
+
+  RETURN_IF_ERROR(mangle(storage, depth + 1));
+
+  return ManglingError::Success;
+}
+
+ManglingError Remangler::mangleExtendedExistentialValueStorage(Node *node,
+                                                           unsigned depth) {
+  if (node->getText() == "opaque")
+    Buffer << "o";
+  else if (node->getText() == "class")
+    Buffer << "c";
+  else if (node->getText() == "metatype")
+    Buffer << "m";
+  else
+    return MANGLING_ERROR(ManglingError::UnknownEncoding, node);
+
+  return ManglingError::Success;
+}
+
 } // anonymous namespace
 
 /// The top-level interface to the remangler.
diff --git a/lib/IRGen/IRGenMangler.cpp b/lib/IRGen/IRGenMangler.cpp
@@ -397,3 +397,69 @@ std::string IRGenMangler::mangleSymbolNameForGenericEnvironment(
   appendGenericSignature(genericSig);
   return finalize();
 }
+
+std::string
+IRGenMangler::mangleExtendedExistentialTypeShape(bool isUnique,
+                                                 CanGenericSignature genSig,
+                                                 CanExistentialType type,
+                                                 unsigned metatypeDepth) {
+  beginMangling();
+
+  appendExtendedExistentialTypeShape(genSig, type, metatypeDepth);
+
+  // If this is non-unique, add a suffix to avoid accidental misuse
+  // (and to make it easier to analyze in an image).
+  if (!isUnique)
+    appendOperator("Mq");
+
+  return finalize();
+}
+
+std::string
+IRGenMangler::mangleExtendedExistentialTypeShapeForUniquing(
+                                                 CanGenericSignature genSig,
+                                                 CanExistentialType type,
+                                                 unsigned metatypeDepth) {
+  beginManglingWithoutPrefix();
+  appendExtendedExistentialTypeShape(genSig, type, metatypeDepth);
+  return finalize();
+}
+void
+IRGenMangler::appendExtendedExistentialTypeShape(CanGenericSignature genSig,
+                                                 CanExistentialType type,
+                                                 unsigned metatypeDepth) {
+  // Append the requirement signature of the existential.
+  auto &ctx = type->getASTContext();
+  auto reqSig = ctx.getOpenedArchetypeSignature(type, genSig);
+  appendGenericSignature(reqSig, genSig);
+
+  // Append the generalization signature.
+  if (genSig) appendGenericSignature(genSig);
+
+  // Append the type expression, if we have metatypes.
+  // Metatypes are called out because they're currently the only
+  // type expression we support.
+  if (metatypeDepth) {
+    assert(reqSig.getGenericParams().size() == 1);
+    Type type = reqSig.getGenericParams()[0];
+    for (unsigned i = 0; i != metatypeDepth; ++i)
+      type = MetatypeType::get(type);
+    appendType(type, reqSig);
+  }
+
+  // Append the shape operator.
+  if (!genSig) {
+    appendOperator(metatypeDepth ? "Xh" : "Xg");
+  } else {
+    appendOperator(metatypeDepth ? "XH" : "XG");
+  }
+
+  // Append the value storage.
+  if (metatypeDepth)
+    appendOperator("m");
+  else if (type->requiresClass())
+    appendOperator("c");
+  else
+    appendOperator("o");
+}
+
diff --git a/lib/IRGen/IRGenMangler.h b/lib/IRGen/IRGenMangler.h
@@ -468,6 +468,22 @@ class IRGenMangler : public Mangle::ASTMangler {
     }
   }
 
+  void appendExtendedExistentialTypeShape(CanGenericSignature genSig,
+                                          CanExistentialType type,
+                                          unsigned metatypeDepth);
+
+  /// Mangle the symbol name for an extended existential type shape.
+  std::string mangleExtendedExistentialTypeShape(bool isUnique,
+                                                 CanGenericSignature genSig,
+                                                 CanExistentialType type,
+                                                 unsigned metatypeDepth);
+
+  /// Mangle an extended existential type shape for the uniquing hash.
+  std::string mangleExtendedExistentialTypeShapeForUniquing(
+                                                 CanGenericSignature genSig,
+                                                 CanExistentialType type,
+                                                 unsigned metatypeDepth);
+
   std::string mangleCoroutineContinuationPrototype(CanSILFunctionType type) {
     return mangleTypeSymbol(type, "TC");
   }
