[Reflection] Clean up the ReflectionContext additions.

Move the internal runtime structures into RuntimeInternals.h. Remove leftover methods. Comment the new methods.

rdar://problem/55481578

Author: mikeash

include/swift/Reflection/ReflectionContext.h

@@ -28,6 +28,7 @@
 #include "swift/Remote/MemoryReader.h"
 #include "swift/Remote/MetadataReader.h"
 #include "swift/Reflection/Records.h"
+#include "swift/Reflection/RuntimeInternals.h"
 #include "swift/Reflection/TypeLowering.h"
 #include "swift/Reflection/TypeRef.h"
 #include "swift/Reflection/TypeRefBuilder.h"
@@ -772,16 +773,6 @@ class ReflectionContext
     }
   }
 
-  
-
-  struct ConformanceNode {
-    StoredPointer Left, Right;
-    StoredPointer Type;
-    StoredPointer Proto;
-    StoredPointer Description;
-    StoredSize FailureGeneration;
-  };
-
   StoredSignedPointer getTypeContextDescriptor(const TargetMetadata<Runtime> *Metadata) const {
     switch (Metadata->getKind()) {
     case MetadataKind::Class: {
@@ -803,19 +794,25 @@ class ReflectionContext
     }
   }
 
+  /// Iterate the protocol conformance cache tree rooted at NodePtr, calling
+  /// Call with the type and protocol in each node.
   void iterateConformanceTree(StoredPointer NodePtr,
     std::function<void(StoredPointer Type, StoredPointer Proto)> Call) {
     if (!NodePtr)
       return;
     auto NodeBytes = getReader().readBytes(RemoteAddress(NodePtr), sizeof(Node));
-    auto NodeData = reinterpret_cast<const ConformanceNode *>(NodeBytes.get());
+    auto NodeData =
+      reinterpret_cast<const ConformanceNode<Runtime> *>(NodeBytes.get());
     if (!NodeData)
       return;
     Call(NodeData->Type, NodeData->Proto);
     iterateConformanceTree(NodeData->Left, Call);
     iterateConformanceTree(NodeData->Right, Call);
   }
 
+  /// Iterate the protocol conformance cache in the target process, calling Call
+  /// with the type and protocol of each conformance. Returns None on success,
+  /// and a string describing the error on failure.
   llvm::Optional<std::string> iterateConformances(
     std::function<void(StoredPointer Type, StoredPointer Proto)> Call) {
     std::string ConformancesPointerName =
@@ -836,20 +833,10 @@ class ReflectionContext
     return llvm::None;
   }
 
-  void iterateModules(Demangle::NodePointer Ptr, std::function<void(llvm::StringRef)> Call) {
-    if (Ptr->getKind() == Node::Kind::Module)
-      Call(Ptr->getText());
-    for (auto Child : *Ptr)
-      iterateModules(Child, Call);
-  }
-  
-  struct MetadataAllocation {
-    uint16_t Tag;
-    StoredPointer Ptr;
-    unsigned Size;
-  };
-
-  StoredPointer allocationMetadataPointer(MetadataAllocation Allocation) {
+  /// Fetch the metadata pointer from a metadata allocation, or 0 if this
+  /// allocation's tag is not handled or an error occurred.
+  StoredPointer allocationMetadataPointer(
+    MetadataAllocation<Runtime> Allocation) {
     if (Allocation.Tag == GenericMetadataCacheTag) {
         struct GenericMetadataCacheEntry {
           StoredPointer Left, Right;
@@ -872,9 +859,12 @@ class ReflectionContext
     }
     return 0;
   }
-  
-  llvm::Optional<std::string>
-  iterateMetadataAllocations(std::function<void (MetadataAllocation)> Call) {
+
+  /// Iterate the metadata allocations in the target process, calling Call with
+  /// each allocation found. Returns None on success, and a string describing
+  /// the error on failure.
+  llvm::Optional<std::string> iterateMetadataAllocations(
+    std::function<void (MetadataAllocation<Runtime>)> Call) {
     std::string IterationEnabledName =
       "__swift_debug_metadataAllocationIterationEnabled";
     std::string AllocationPoolPointerName =
@@ -940,7 +930,7 @@ class ReflectionContext
         if (Header->Size == 0)
           break;
         auto RemoteAddr = PoolStart + Offset + sizeof(AllocationHeader);
-        MetadataAllocation Allocation;
+        MetadataAllocation<Runtime> Allocation;
         Allocation.Tag = Header->Tag;
         Allocation.Ptr = RemoteAddr;
         Allocation.Size = Header->Size;

include/swift/Reflection/RuntimeInternals.h

@@ -0,0 +1,47 @@
+//===--- RuntimeInternals.h - Runtime Internal Structures -------*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// Runtime data structures that Reflection inspects externally.
+//
+// FIXME: Ideally the original definitions would be templatized on a Runtime
+// parameter and we could use the original definitions in both the runtime and
+// in Reflection.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_REFLECTION_RUNTIME_INTERNALS_H
+#define SWIFT_REFLECTION_RUNTIME_INTERNALS_H
+
+namespace swift {
+
+namespace reflection {
+
+template <typename Runtime>
+struct ConformanceNode {
+  typename Runtime::StoredPointer Left, Right;
+  typename Runtime::StoredPointer Type;
+  typename Runtime::StoredPointer Proto;
+  typename Runtime::StoredPointer Description;
+  typename Runtime::StoredSize FailureGeneration;
+};
+
+template <typename Runtime>
+struct MetadataAllocation {
+  uint16_t Tag;
+  typename Runtime::StoredPointer Ptr;
+  unsigned Size;
+};
+
+} // end namespace reflection
+} // end namespace swift
+
+#endif // SWIFT_REFLECTION_RUNTIME_INTERNALS_H

stdlib/public/SwiftRemoteMirror/SwiftRemoteMirror.cpp

@@ -33,8 +33,8 @@ using namespace swift;
 using namespace swift::reflection;
 using namespace swift::remote;
 
-using NativeReflectionContext = swift::reflection::ReflectionContext<
-    External<RuntimeTarget<sizeof(uintptr_t)>>>;
+using Runtime = External<RuntimeTarget<sizeof(uintptr_t)>>;
+using NativeReflectionContext = swift::reflection::ReflectionContext<Runtime>;
 
 struct SwiftReflectionContext {
   NativeReflectionContext *nativeContext;
@@ -629,7 +629,7 @@ swift_reflection_ptr_t swift_reflection_allocationMetadataPointer(
   SwiftReflectionContextRef ContextRef,
   swift_metadata_allocation_t Allocation) {
   auto Context = ContextRef->nativeContext;
-  NativeReflectionContext::MetadataAllocation NativeAllocation;
+  MetadataAllocation<Runtime> NativeAllocation;
   NativeAllocation.Tag = Allocation.Tag;
   NativeAllocation.Ptr = Allocation.Ptr;
   NativeAllocation.Size = Allocation.Size;