[Demangler] Stable parent identifier in OpaqueReturnTypeParent

`OpaqueReturnTypeParent` node now references the parent with a mangled parent name, rather than a parent pointer. This makes trees obtained from different demanglers (or calls to `Demangler::demangleSymbol`) for the same symbol equal.

Author: DmT021

include/swift/Demangling/Demangle.h

@@ -243,6 +243,25 @@ class Node {
     }
   }
 
+  static bool deepEquals(const Node *lhs, const Node *rhs) {
+    if (lhs == rhs)
+      return true;
+    if ((!lhs && rhs) || (lhs && !rhs))
+      return false;
+    if (!lhs->isSimilarTo(rhs))
+      return false;
+    for (auto li = lhs->begin(), ri = rhs->begin(), le = lhs->end(); li != le;
+         ++li, ++ri) {
+      if (!deepEquals(*li, *ri))
+        return false;
+    }
+    return true;
+  }
+
+  bool isDeepEqualTo(const Node *other) const {
+    return deepEquals(this, other);
+  }
+
   bool hasText() const { return NodePayloadKind == PayloadKind::Text; }
   llvm::StringRef getText() const {
     assert(hasText());

lib/Demangling/Demangler.cpp

@@ -1532,34 +1532,53 @@ NodePointer Demangler::demangleExtensionContext() {
 
 /// Associate any \c OpaqueReturnType nodes with the declaration whose opaque
 /// return type they refer back to.
-static Node *setParentForOpaqueReturnTypeNodes(Demangler &D,
-                                              Node *parent,
-                                              Node *visitedNode) {
-  if (!parent || !visitedNode)
-    return nullptr;
-  if (visitedNode->getKind() == Node::Kind::OpaqueReturnType) {
+/// Implementation for \c setParentForOpaqueReturnTypeNodes. Don't invoke
+/// directly.
+static void setParentForOpaqueReturnTypeNodesImpl(
+    Demangler &D, Node &visitedNode,
+    llvm::function_ref<StringRef()> getParentID) {
+  if (visitedNode.getKind() == Node::Kind::OpaqueReturnType) {
     // If this node is not already parented, parent it.
-    if (visitedNode->hasChildren()
-        && visitedNode->getLastChild()->getKind() == Node::Kind::OpaqueReturnTypeParent) {
-      return parent;
+    if (visitedNode.hasChildren() && visitedNode.getLastChild()->getKind() ==
+                                         Node::Kind::OpaqueReturnTypeParent) {
+      return;
     }
-    visitedNode->addChild(D.createNode(Node::Kind::OpaqueReturnTypeParent,
-                                       (Node::IndexType)parent), D);
-    return parent;
+    visitedNode.addChild(D.createNode(Node::Kind::OpaqueReturnTypeParent,
+                                      StringRef(getParentID())),
+                         D);
+    return;
   }
-  
+
   // If this node is one that may in turn define its own opaque return type,
   // stop recursion, since any opaque return type nodes underneath would refer
   // to the nested declaration rather than the one we're looking at.
-  if (visitedNode->getKind() == Node::Kind::Function
-      || visitedNode->getKind() == Node::Kind::Variable
-      || visitedNode->getKind() == Node::Kind::Subscript) {
-    return parent;
+  if (visitedNode.getKind() == Node::Kind::Function ||
+      visitedNode.getKind() == Node::Kind::Variable ||
+      visitedNode.getKind() == Node::Kind::Subscript) {
+    return;
   }
-  
-  for (size_t i = 0, e = visitedNode->getNumChildren(); i < e; ++i) {
-    setParentForOpaqueReturnTypeNodes(D, parent, visitedNode->getChild(i));
+
+  for (Node *child : visitedNode) {
+    assert(child);
+    setParentForOpaqueReturnTypeNodesImpl(D, *child, getParentID);
   }
+}
+
+/// Associate any \c OpaqueReturnType nodes with the declaration whose opaque
+/// return type they refer back to.
+static Node *setParentForOpaqueReturnTypeNodes(Demangler &D, Node *parent,
+                                               Node *visitedNode) {
+  if (!parent || !visitedNode)
+    return nullptr;
+  std::string parentID;
+  setParentForOpaqueReturnTypeNodesImpl(D, *visitedNode, [&] {
+    if (!parentID.empty())
+      return StringRef(parentID);
+    const auto mangleResult = mangleNode(parent);
+    assert(mangleResult.isSuccess());
+    parentID = mangleResult.result();
+    return StringRef(parentID);
+  });
   return parent;
 }
 

unittests/Basic/DemangleTest.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Demangling/Demangle.h"
+#include "swift/Demangling/Demangler.h"
 #include "gtest/gtest.h"
 
 using namespace swift::Demangle;
@@ -43,3 +44,17 @@ TEST(Demangle, CustomGenericParameterNames) {
   std::string Result = demangleSymbolAsString(SymbolName, Options);
   EXPECT_STREQ(DemangledName.c_str(), Result.c_str());
 }
+
+TEST(Demangle, DeepEquals) {
+  static std::string Symbols[]{
+#define SYMBOL(Mangled, Demangled) Mangled,
+#include "ManglingTestData.def"
+  };
+  for (const auto &Symbol : Symbols) {
+    Demangler D1;
+    Demangler D2;
+    auto tree1 = D1.demangleSymbol(Symbol);
+    auto tree2 = D2.demangleSymbol(Symbol);
+    EXPECT_TRUE(tree1->isDeepEqualTo(tree2)) << "Failing symbol: " << Symbol;
+  }
+}