Refactor gathering of field type info from a binary into two steps: collect and output.

The collect step can then be used for other tools, such as the `BinaryScanningTool`.

Author: artemcm

include/swift-c/StaticMirror/BinaryScan.h

@@ -25,7 +25,7 @@
 /// SWIFTSTATICMIRROR_VERSION_MINOR should increase when there are API additions.
 /// SWIFTSTATICMIRROR_VERSION_MAJOR is intended for "major" source/ABI breaking changes.
 #define SWIFTSTATICMIRROR_VERSION_MAJOR 0
-#define SWIFTSTATICMIRROR_VERSION_MINOR 2 // Added associated-type gather
+#define SWIFTSTATICMIRROR_VERSION_MINOR 3 // Added filed type info gather
 
 SWIFTSTATICMIRROR_BEGIN_DECLS
 

include/swift/Reflection/TypeRefBuilder.h

@@ -317,6 +317,29 @@ struct AssociatedTypeCollectionResult {
   std::vector<std::string> Errors;
 };
 
+struct PropertyTypeInfo {
+  std::string Label;
+  std::string TypeMangledName;
+  std::string TypeFullyQualifiedName;
+  std::string TypeDiagnosticPrintName;
+};
+
+struct EnumCaseInfo {
+  std::string Label;
+};
+
+struct FieldMetadata {
+  std::string MangledTypeName;
+  std::string FullyQualifiedName;
+  std::vector<PropertyTypeInfo> Properties;
+  std::vector<EnumCaseInfo> EnumCases;
+};
+
+struct FieldTypeCollectionResult {
+  std::vector<FieldMetadata> FieldInfos;
+  std::vector<std::string> Errors;
+};
+
 /// An implementation of MetadataReader's BuilderType concept for
 /// building TypeRefs, and parsing field metadata from any images
 /// it has been made aware of.
@@ -899,6 +922,7 @@ class TypeRefBuilder {
 
   void dumpTypeRef(RemoteRef<char> MangledName, std::ostream &stream,
                    bool printTypeName = false);
+  FieldTypeCollectionResult collectFieldTypes(llvm::Optional<std::string> forMangledTypeName);
   void dumpFieldSection(std::ostream &stream);
   AssociatedTypeCollectionResult collectAssociatedTypes(llvm::Optional<std::string> forMangledTypeName);
   void dumpAssociatedTypeSection(std::ostream &stream);

include/swift/StaticMirror/BinaryScanningTool.h

@@ -54,6 +54,14 @@ class BinaryScanningTool {
   reflection::AssociatedTypeCollectionResult
   collectAllAssociatedTypes();
 
+  /// Collect all field type infos of the specified type
+  reflection::FieldTypeCollectionResult
+  collectFieldTypes(const std::string &mangledTypeName);
+
+  /// Collect field type infos of all discovered types
+  reflection::FieldTypeCollectionResult
+  collectAllFieldTypes();
+
 private:
   // Note: binaryOrError and objectOrError own the memory for our ObjectFile;
   // once they go out of scope, we can no longer do anything.

lib/StaticMirror/BinaryScanningTool.cpp

@@ -87,5 +87,15 @@ AssociatedTypeCollectionResult
 BinaryScanningTool::collectAllAssociatedTypes() {
   return Context->Builder.collectAssociatedTypes(llvm::Optional<std::string>());
 }
+
+FieldTypeCollectionResult
+BinaryScanningTool::collectFieldTypes(const std::string &mangledTypeName) {
+  return Context->Builder.collectFieldTypes(mangledTypeName);
+}
+
+FieldTypeCollectionResult
+BinaryScanningTool::collectAllFieldTypes() {
+  return Context->Builder.collectFieldTypes(llvm::Optional<std::string>());
+}
 } // end namespace static_mirror
 } // end namespace swift

stdlib/public/Reflection/TypeRefBuilder.cpp

@@ -432,30 +432,76 @@ void TypeRefBuilder::dumpTypeRef(RemoteRef<char> MangledName,
   stream << "\n";
 }
 
-void TypeRefBuilder::dumpFieldSection(std::ostream &stream) {
+FieldTypeCollectionResult TypeRefBuilder::collectFieldTypes(
+    llvm::Optional<std::string> forMangledTypeName) {
+  FieldTypeCollectionResult result;
   for (const auto &sections : ReflectionInfos) {
     for (auto descriptor : sections.Field) {
-      auto TypeDemangling =
-          demangleTypeRef(readTypeRef(descriptor, descriptor->MangledTypeName));
-      auto TypeName = nodeToString(TypeDemangling);
+      auto typeRef = readTypeRef(descriptor, descriptor->MangledTypeName);
+      auto typeName = nodeToString(demangleTypeRef(typeRef));
+      auto optionalMangledTypeName = normalizeReflectionName(typeRef);
       clearNodeFactory();
-      stream << TypeName.c_str() << "\n";
-      for (size_t i = 0; i < TypeName.size(); ++i)
-        stream << "-";
-      stream << "\n";
-      for (auto &fieldRef : *descriptor.getLocalBuffer()) {
-        auto field = descriptor.getField(fieldRef);
-        auto fieldName = getTypeRefString(readTypeRef(field, field->FieldName));
-        stream.write(fieldName.data(), fieldName.size());
-        if (field->hasMangledTypeName()) {
-          stream << ": ";
-          dumpTypeRef(readTypeRef(field, field->MangledTypeName), stream);
-        } else {
-          stream << "\n\n";
+      if (optionalMangledTypeName.hasValue()) {
+        auto mangledTypeName =
+            optionalMangledTypeName.getValue().insert(0, "$s");
+        if (forMangledTypeName.hasValue()) {
+          if (mangledTypeName != forMangledTypeName.getValue())
+            continue;
         }
+
+        std::vector<PropertyTypeInfo> properties;
+        std::vector<EnumCaseInfo> enumCases;
+        for (auto &fieldRef : *descriptor.getLocalBuffer()) {
+          auto field = descriptor.getField(fieldRef);
+          auto fieldName = getTypeRefString(readTypeRef(field, field->FieldName));
+          if (field->hasMangledTypeName()) {
+            std::string mangledFieldTypeName =
+                std::string(field->MangledTypeName);
+            auto fieldTypeRef = readTypeRef(field, field->MangledTypeName);
+            auto optionalMangledfieldTypeName =
+                normalizeReflectionName(fieldTypeRef);
+            if (optionalMangledfieldTypeName.hasValue()) {
+              mangledFieldTypeName =
+                  "$s" + optionalMangledfieldTypeName.getValue();
+            }
+            auto fieldTypeDemangleTree = demangleTypeRef(fieldTypeRef);
+            auto fieldTypeName = nodeToString(fieldTypeDemangleTree);
+            std::stringstream OS;
+            dumpTypeRef(fieldTypeRef, OS);
+            properties.emplace_back(PropertyTypeInfo{fieldName.str(),
+                                                     mangledFieldTypeName,
+                                                     fieldTypeName, OS.str()});
+          } else {
+            enumCases.emplace_back(EnumCaseInfo{fieldName.str()});
+          }
+        }
+        result.FieldInfos.emplace_back(FieldMetadata{
+            mangledTypeName, typeName, properties, enumCases});
       }
     }
   }
+
+  return result;
+}
+
+void TypeRefBuilder::dumpFieldSection(std::ostream &stream) {
+  auto fieldInfoCollectionResult =
+      collectFieldTypes(llvm::Optional<std::string>());
+  for (const auto &info : fieldInfoCollectionResult.FieldInfos) {
+    stream << info.FullyQualifiedName << "\n";
+    for (size_t i = 0; i < info.FullyQualifiedName.size(); ++i)
+      stream << "-";
+    stream << "\n";
+    for (const auto &field : info.Properties) {
+      stream << field.Label;
+      stream << ": ";
+      stream << field.TypeDiagnosticPrintName;
+    }
+    for (const auto &field : info.EnumCases) {
+      stream << field.Label;
+      stream << "\n\n";
+    }
+  }
 }
 
 AssociatedTypeCollectionResult TypeRefBuilder::collectAssociatedTypes(

tools/swift-reflection-dump/swift-reflection-dump.cpp

@@ -30,6 +30,8 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Error.h"
 
+#include "swift/StaticMirror/BinaryScanningTool.h"
+
 #if defined(_WIN32)
 #include <io.h>
 #else