Runtime: Handle symbolic references inside other mangling nodes

Previously we could only handle symbolic references at the
top level, but this is insufficient; for example, you can
have a nested type X.Y where X is defined in the current
translation unit and Y is defined in an extension of X in
a different translation unit. In this case, X.Y mangles as
a tree where the child contains a symbolic reference to X.

Handle this by adding a new form of Demangle::mangleNode()
which takes a callback for resolving symbolic references.

Fixes <rdar://problem/39613190>.

Author: slavapestov

include/swift/Demangling/Demangle.h

@@ -466,6 +466,14 @@ void mangleIdentifier(const char *data, size_t length,
 /// This should always round-trip perfectly with demangleSymbolAsNode.
 std::string mangleNode(const NodePointer &root);
 
+using SymbolicResolver = llvm::function_ref<Demangle::NodePointer (const void *)>;
+
+/// \brief Remangle a demangled parse tree, using a callback to resolve
+/// symbolic references.
+///
+/// This should always round-trip perfectly with demangleSymbolAsNode.
+std::string mangleNode(const NodePointer &root, SymbolicResolver resolver);
+
 /// Remangle in the old mangling scheme.
 ///
 /// This is only used for objc-runtime names and should be removed as soon as

lib/Demangling/Remangler.cpp

@@ -152,6 +152,9 @@ class Remangler {
   // nested generics. This factory owns them.
   NodeFactory Factory;
 
+  // A callback for resolving symbolic references.
+  SymbolicResolver Resolver;
+
   StringRef getBufferStr() const { return Buffer.getStringRef(); }
 
   void resetBuffer(size_t toPos) { Buffer.resetSize(toPos); }
@@ -284,7 +287,8 @@ class Remangler {
 #include "swift/Demangling/DemangleNodes.def"
 
 public:
-  Remangler(DemanglerPrinter &Buffer) : Buffer(Buffer) {}
+  Remangler(DemanglerPrinter &Buffer,
+            SymbolicResolver Resolver) : Buffer(Buffer), Resolver(Resolver) {}
 
   void mangle(Node *node) {
     switch (node->getKind()) {
@@ -1994,18 +1998,25 @@ void Remangler::mangleUnresolvedSymbolicReference(Node *node) {
 }
 
 void Remangler::mangleSymbolicReference(Node *node) {
-  unreachable("should not try to mangle a symbolic reference; "
-              "resolve it to a non-symbolic demangling tree instead");
+  return mangle(Resolver((const void *)node->getIndex()));
 }
 
 } // anonymous namespace
 
 /// The top-level interface to the remangler.
 std::string Demangle::mangleNode(const NodePointer &node) {
+  return mangleNode(node, [](const void *) -> NodePointer {
+    unreachable("should not try to mangle a symbolic reference; "
+                "resolve it to a non-symbolic demangling tree instead");
+  });
+}
+
+std::string
+Demangle::mangleNode(const NodePointer &node, SymbolicResolver resolver) {
   if (!node) return "";
 
   DemanglerPrinter printer;
-  Remangler(printer).mangle(node);
+  Remangler(printer, resolver).mangle(node);
 
   return std::move(printer).str();
 }

stdlib/public/runtime/MetadataLookup.cpp

@@ -263,7 +263,8 @@ _searchTypeMetadataRecords(const TypeMetadataPrivateState &T,
 }
 
 static const TypeContextDescriptor *
-_findNominalTypeDescriptor(Demangle::NodePointer node) {
+_findNominalTypeDescriptor(Demangle::NodePointer node,
+                           Demangle::Demangler &Dem) {
   const TypeContextDescriptor *foundNominal = nullptr;
   auto &T = TypeMetadataRecords.get();
 
@@ -275,7 +276,13 @@ _findNominalTypeDescriptor(Demangle::NodePointer node) {
     return cast<TypeContextDescriptor>(
       (const ContextDescriptor *)symbolicNode->getIndex());
 
-  auto mangledName = Demangle::mangleNode(node);
+  auto 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.
@@ -696,7 +703,7 @@ class DecodedMetadataBuilder {
 #endif
 
     // Look for a nominal type descriptor based on its mangled name.
-    return _findNominalTypeDescriptor(node);
+    return _findNominalTypeDescriptor(node, demangler);
   }
 
   BuiltProtocolDecl createProtocolDecl(

test/stdlib/Inputs/Mirror/MirrorOther.swift

@@ -0,0 +1,7 @@
+struct OtherStruct {
+  let a: OtherOuter.Inner
+  let b: OtherOuterGeneric<Int>.Inner<String>
+}
+
+struct OtherOuter {}
+struct OtherOuterGeneric<T> {}

test/stdlib/Mirror.swift

@@ -10,13 +10,14 @@
 //
 //===----------------------------------------------------------------------===//
 // RUN: %empty-directory(%t)
+// RUN: cp %s %t/main.swift
 //
 // RUN: if [ %target-runtime == "objc" ]; \
 // RUN: then \
 // RUN:   %target-clang %S/Inputs/Mirror/Mirror.mm -c -o %t/Mirror.mm.o -g && \
-// RUN:   %target-build-swift %s -I %S/Inputs/Mirror/ -Xlinker %t/Mirror.mm.o -o %t/Mirror; \
+// RUN:   %target-build-swift %t/main.swift %S/Inputs/Mirror/MirrorOther.swift -I %S/Inputs/Mirror/ -Xlinker %t/Mirror.mm.o -o %t/Mirror; \
 // RUN: else \
-// RUN:   %target-build-swift %s -o %t/Mirror; \
+// RUN:   %target-build-swift %t/main.swift %S/Inputs/Mirror/MirrorOther.swift -o %t/Mirror; \
 // RUN: fi
 // RUN: %target-run %t/Mirror
 // REQUIRES: executable_test
@@ -791,11 +792,34 @@ struct e<f> {
     var constraints: [Int: a<f>.c] = [:]
 }
 
-mirrors.test("field with generic nested type") {
+mirrors.test("GenericNestedTypeField") {
   let x = e<d>()
 
   expectTrue(type(of: Mirror(reflecting: x).children.first!.value)
               == [Int: a<d>.c].self)
 }
 
+extension OtherOuter {
+  struct Inner {}
+}
+
+extension OtherOuterGeneric {
+  struct Inner<U> {}
+}
+
+mirrors.test("SymbolicReferenceInsideType") {
+  let s = OtherStruct(a: OtherOuter.Inner(),
+                      b: OtherOuterGeneric<Int>.Inner<String>())
+
+  var output = ""
+  dump(s, to: &output)
+
+  let expected =
+    "▿ Mirror.OtherStruct\n" +
+    "  - a: Mirror.OtherOuter.Inner\n" +
+    "  - b: Mirror.OtherOuterGeneric<Swift.Int>.Inner<Swift.String>\n"
+
+  expectEqual(expected, output)
+}
+
 runAllTests()