[Remote AST] Resolve extension context descriptors to demangle trees.

Read the extended context mangled name from an extension context descriptor
so we can form a proper demangle tree for extensions. For example, this allows
types nested within extensions of types from different modules to be found.

Author: DougGregor

include/swift/ABI/Metadata.h

@@ -2784,6 +2784,7 @@ struct TargetExtensionContextDescriptor final
   using TrailingGenericContextObjects
     = TrailingGenericContextObjects<TargetExtensionContextDescriptor<Runtime>>;
 
+public:
   /// A mangling of the `Self` type context that the extension extends.
   /// The mangled name represents the type in the generic context encoded by
   /// this descriptor. For example, a nongeneric nominal type extension will
@@ -2794,7 +2795,6 @@ struct TargetExtensionContextDescriptor final
   /// extension is declared inside.
   RelativeDirectPointer<const char> ExtendedContext;
 
-public:
   using TrailingGenericContextObjects::getGenericContext;
 
   StringRef getMangledExtendedContext() const {

include/swift/Remote/MetadataReader.h

@@ -1438,6 +1438,7 @@ class MetadataReader {
     auto mangledNameAddress = resolveRelativeField(contextRef,
                                                    mangledContextName->name);
 
+    // FIXME: Symbolic references can break this
     std::string mangledName;
     if (!Reader->readString(RemoteAddress(mangledNameAddress), mangledName))
       return nullptr;
@@ -1589,10 +1590,40 @@ class MetadataReader {
       nodeKind = Demangle::Node::Kind::Protocol;
       break;
     }
-    case ContextDescriptorKind::Extension:
-      // TODO: Remangle something about the extension context here.
+    case ContextDescriptorKind::Extension: {
+      // There should always be a parent describing where the extension
+      // lives.
+      if (!parentDemangling) {
+        return nullptr;
+      }
+
+      auto extensionBuffer =
+        reinterpret_cast<const TargetExtensionContextDescriptor<Runtime> *>(
+          descriptor.getLocalBuffer());
+
+      auto extendedContextAddress =
+        resolveRelativeField(descriptor, extensionBuffer->ExtendedContext);
+
+      // FIXME: Symbolic references can break this
+      std::string mangledExtendedContext;
+      if (!Reader->readString(RemoteAddress(extendedContextAddress),
+                              mangledExtendedContext))
+        return nullptr;
+
+      auto demangledExtendedContext = dem.demangleType(mangledExtendedContext);
+      if (!demangledExtendedContext)
+        return nullptr;
+
+      // FIXME: If there are generic requirements, turn them into a demangle
+      // tree.
+      auto demangling = dem.createNode(Node::Kind::Extension);
+      demangling->addChild(parentDemangling, dem);
+      demangling->addChild(demangledExtendedContext, dem);
+      return demangling;
+
       return nullptr;
-      
+    }
+
     case ContextDescriptorKind::Anonymous: {
       // Use the remote address to identify the anonymous context.
       char addressBuf[18];

test/RemoteAST/extensions.swift

@@ -0,0 +1,13 @@
+// RUN: %target-swift-remoteast-test %s | %FileCheck %s
+
+// REQUIRES: swift-remoteast-test
+
+@_silgen_name("printMetadataType")
+func printType(_: Any.Type)
+
+extension Int {
+  struct Inner { }
+}
+
+// CHECK: Int.Inner
+printType(Int.Inner.self)