Add CaptureDescriptor struct definition

For convenience when reading looking at heap closure metadata.

Also move the capture typerefs above the metadata sources, since
they're more likely to be accessed than generic metadata sources.

Author: bitjammer

include/swift/Reflection/Records.h

@@ -341,6 +341,63 @@ class BuiltinTypeDescriptorIterator
   }
 };
 
+/// A key-value pair in a TypeRef -> MetadataSource map.
+struct GenericMetadataSource {
+  using Key = RelativeDirectPointer<const char>;
+  using Value = Key;
+
+  const Key MangledTypeName;
+  const Value EncodedMetadataSource;
+};
+
+/// Describes the layout of a heap closure.
+///
+/// For simplicity's sake and other reasons, this shouldn't contain
+/// architecture-specifically sized things like direct pointers, uintptr_t, etc.
+struct CaptureDescriptor {
+public:
+
+  /// The number of captures in the closure and the number of typerefs that
+  /// immediately follow this struct.
+  const uint32_t NumCaptures;
+
+  /// The number of sources of metadata available in the MetadataSourceMap
+  /// directly following the list of capture's typerefs.
+  const uint32_t NumMetadataSources;
+
+  /// The number of items in the NecessaryBindings structure at the head of
+  /// the closure.
+  const uint32_t NumBindings;
+
+  /// Get the key-value pair for the ith generic metadata source.
+  const GenericMetadataSource &getGenericMetadataSource(size_t i) const {
+    assert(i <= NumMetadataSources &&
+           "Generic metadata source index out of range");
+    auto Begin = getGenericMetadataSourceBuffer();
+    return Begin[i];
+  }
+
+  /// Get the typeref (encoded as a mangled type name) of the ith
+  /// closure capture.
+  const RelativeDirectPointer<const char> &
+  getCaptureMangledTypeName(size_t i) const {
+    assert(i <= NumCaptures && "Capture index out of range");
+    auto Begin = getCaptureTypeRefBuffer();
+    return Begin[i];
+  }
+
+private:
+  const GenericMetadataSource *getGenericMetadataSourceBuffer() const {
+    auto BeginTR = reinterpret_cast<const char *>(getCaptureTypeRefBuffer());
+    auto EndTR = BeginTR + NumCaptures * sizeof(GenericMetadataSource);
+    return reinterpret_cast<const GenericMetadataSource *>(EndTR );
+  }
+
+  const RelativeDirectPointer<const char> *getCaptureTypeRefBuffer() const {
+    return reinterpret_cast<const RelativeDirectPointer<const char> *>(this+1);
+  }
+};
+
 } // end namespace reflection
 } // end namespace swift
 

lib/IRGen/GenReflection.cpp

@@ -636,6 +636,11 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
     addConstantInt32(MetadataSources.size());
     addConstantInt32(Layout.getBindings().size());
 
+    // Now add typerefs of all of the captures.
+    for (auto CaptureType : CaptureTypes) {
+      addTypeRef(Callee.getModule().getSwiftModule(), CaptureType);
+    }
+
     // Add the pairs that make up the generic param -> metadata source map
     // to the struct.
     for (auto GenericAndSource : MetadataSources) {
@@ -644,11 +649,6 @@ class CaptureDescriptorBuilder : public ReflectionMetadataBuilder {
       addTypeRef(nullptr, GenericParam);
       addMetadataSource(Source);
     }
-
-    // Now add typerefs of all of the captures.
-    for (auto CaptureType : CaptureTypes) {
-      addTypeRef(Callee.getModule().getSwiftModule(), CaptureType);
-    }
   }
 
   llvm::GlobalVariable *emit() {