Add a getKindForRemoteTypeMetadata() API to the RemoteAST - LLDB plans to use this API to decide whether certain kinds of existential containers need a two-level type resolution (e.g. if an existential box points to a class, the true type that we want to resolve is the type that the class's ISA refers to, not the static type that the box refers to)

Author: Enrico Granata

include/swift/Remote/MetadataReader.h

@@ -24,6 +24,7 @@
 
 #include <vector>
 #include <unordered_map>
+#include <utility>
 
 namespace swift {
 namespace remote {
@@ -419,6 +420,24 @@ class MetadataReader {
     return swift::remote::decodeMangledType(Builder, Node);
   }
 
+  /// Given a remote pointer to metadata, attempt to discover its MetadataKind.
+  std::pair<bool,MetadataKind>
+  readKindFromMetadata(StoredPointer MetadataAddress) {
+    auto Cached = MetadataCache.find(MetadataAddress);
+    if (Cached != MetadataCache.end()) {
+      if (auto Meta = Cached->second) {
+        return {true,Cached->second->getKind()};
+      } else {
+        return {false,MetadataKind::Opaque};
+      }
+    }
+
+    auto Meta = readMetadata(MetadataAddress);
+    if (!Meta) return {false,MetadataKind::Opaque};
+
+    return {true,Meta->getKind()};
+  }
+
   /// Given a remote pointer to metadata, attempt to turn it into a type.
   BuiltType readTypeFromMetadata(StoredPointer MetadataAddress) {
     auto Cached = TypeCache.find(MetadataAddress);

include/swift/RemoteAST/RemoteAST.h

@@ -22,6 +22,7 @@
 #include "swift/Remote/Failure.h"
 #include "swift/Remote/MemoryReader.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/ABI/MetadataValues.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 
@@ -169,6 +170,11 @@ class RemoteASTContext {
   /// resolve it to a specific type in the local AST.
   Result<Type> getTypeForRemoteTypeMetadata(remote::RemoteAddress address);
 
+  /// Given an address which is supposedly of type metadata, try to
+  /// resolve it to a specific MetadataKind value for its backing type.
+  Result<MetadataKind>
+  getKindForRemoteTypeMetadata(remote::RemoteAddress address);
+
   /// Given an address which is supposedly of a nominal type descriptor,
   /// try to resolve it to a specific nominal type declaration in the
   /// local AST.

lib/RemoteAST/RemoteAST.cpp

@@ -537,6 +537,17 @@ class RemoteASTContextImpl {
     return Result<Type>::emplaceFailure(Failure::Unknown);
   }
 
+  Result<MetadataKind> getKindForRemoteTypeMetadata(RemoteAddress address) {
+    std::pair<bool,MetadataKind> result;
+    if (Is32) {
+      result = Reader32->readKindFromMetadata(address.getAddressData());
+    } else {
+      result = Reader64->readKindFromMetadata(address.getAddressData());
+    }
+    if (result.first) return Result<MetadataKind>(result.second);
+    return Result<MetadataKind>::emplaceFailure(Failure::Unknown);
+  }
+
   Result<NominalTypeDecl *>
   getDeclForRemoteNominalTypeDescriptor(RemoteAddress address) {
     NominalTypeDecl *result;