Remove MetadataPromise from the SwiftArray formatter (NFC)

(cherry picked from commit ce4efb1)

Author: adrian-prantl

lldb/source/Plugins/Language/Swift/SwiftArray.cpp

@@ -14,6 +14,7 @@
 
 #include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Target/Process.h"
@@ -281,7 +282,10 @@ bool SwiftSyntheticFrontEndBufferHandler::IsValid() {
 }
 
 std::unique_ptr<SwiftArrayBufferHandler>
-SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &valobj) {
+SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &static_valobj) {
+  lldb::ValueObjectSP valobj_sp =
+      static_valobj.GetDynamicValue(lldb::eDynamicCanRunTarget);
+  ValueObject &valobj = valobj_sp ? *valobj_sp : static_valobj;
   llvm::StringRef valobj_typename(
       valobj.GetCompilerType().GetTypeName().AsCString(""));
 
@@ -325,22 +329,24 @@ SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &valobj) {
     if (error.Fail() || argmetadata_ptr == LLDB_INVALID_ADDRESS)
       return nullptr;
 
+    // Get the type of the array elements.
+    CompilerType argument_type;
+    auto scratch_ctx_reader = valobj.GetSwiftScratchContext();
+    if (!scratch_ctx_reader)
+      return nullptr;
+    auto *ts = scratch_ctx_reader->get();
+    if (!ts)
+      return nullptr;
     auto *swift_runtime = SwiftLanguageRuntime::Get(process_sp);
     if (!swift_runtime)
       return nullptr;
 
-    CompilerType argument_type;
-
-    SwiftLanguageRuntime::MetadataPromiseSP promise_sp(
-        swift_runtime->GetMetadataPromise(argmetadata_ptr, valobj));
-    if (promise_sp)
-      if (CompilerType type = promise_sp->FulfillTypePromise())
-        if (auto type_system =
-                type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>())
-          argument_type =
-              type_system->GetGenericArgumentType(type.GetOpaqueQualType(), 0);
+    if (CompilerType type =
+            swift_runtime->GetTypeFromMetadata(*ts, argmetadata_ptr))
+      if (auto ts = type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>())
+        argument_type = ts->GetGenericArgumentType(type.GetOpaqueQualType(), 0);
 
-    if (!argument_type.IsValid())
+    if (!argument_type)
       return nullptr;
 
     auto handler = std::unique_ptr<SwiftArrayBufferHandler>(

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp

@@ -265,6 +265,11 @@ class SwiftLanguageRuntimeStub {
     return addr;
   }
 
+  CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address addr) {
+    STUB_LOG();
+    return {};
+  }
+
   SwiftLanguageRuntime::MetadataPromiseSP
   GetMetadataPromise(lldb::addr_t addr, ValueObject &for_object) {
     STUB_LOG();
@@ -2373,6 +2378,11 @@ lldb::addr_t SwiftLanguageRuntime::FixupAddress(lldb::addr_t addr,
   FORWARD(FixupAddress, addr, type, error);
 }
 
+CompilerType SwiftLanguageRuntime::GetTypeFromMetadata(TypeSystemSwift &tss,
+                                                       Address addr) {
+  FORWARD(GetTypeFromMetadata, tss, addr);
+}
+
 SwiftLanguageRuntime::MetadataPromiseSP
 SwiftLanguageRuntime::GetMetadataPromise(lldb::addr_t addr,
                                          ValueObject &for_object) {

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h

@@ -255,6 +255,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
 
   MetadataPromiseSP GetMetadataPromise(lldb::addr_t addr,
                                        ValueObject &for_object);
+  CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address address);
   /// Build the artificial type metadata variable name for \p swift_type.
   static bool GetAbstractTypeName(StreamString &name, swift::Type swift_type);
 

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -1775,7 +1775,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ExistentialMetatype(
     return false;
 
   const swift::reflection::TypeRef *type_ref =
-      reflection_ctx->readTypeFromMetadata(ptr);
+      reflection_ctx->ReadTypeFromMetadata(ptr);
 
   auto tss = meta_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
   if (!tss)
@@ -1799,7 +1799,26 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ExistentialMetatype(
   address.SetRawAddress(ptr);
   return true;
 }
-  
+
+CompilerType SwiftLanguageRuntimeImpl::GetTypeFromMetadata(TypeSystemSwift &ts,
+                                                           Address address) {
+  lldb::addr_t ptr = address.GetLoadAddress(&GetProcess().GetTarget());
+  if (ptr == LLDB_INVALID_ADDRESS)
+    return {};
+
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
+  if (!reflection_ctx)
+    return {};
+
+  const swift::reflection::TypeRef *type_ref =
+      reflection_ctx->ReadTypeFromMetadata(ptr);
+
+  using namespace swift::Demangle;
+  Demangler dem;
+  NodePointer node = type_ref->getDemangling(dem);
+  return ts.GetTypeSystemSwiftTypeRef().RemangleAsType(dem, node);
+}
+
 llvm::Optional<lldb::addr_t>
 SwiftLanguageRuntimeImpl::GetTypeMetadataForTypeNameAndFrame(
     StringRef mdvar_name, StackFrame &frame) {

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeImpl.h

@@ -110,6 +110,7 @@ class SwiftLanguageRuntimeImpl {
   llvm::Optional<size_t> GetBitAlignment(CompilerType type,
                                          ExecutionContextScope *exe_scope);
 
+  CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address address);
   SwiftLanguageRuntime::MetadataPromiseSP
   GetMetadataPromise(lldb::addr_t addr, ValueObject &for_object);