Merge pull request #7574 from adrian-prantl/116361792-5.9

Remove SwiftASTContext from SwiftMetatype_SummaryProvider

Author: adrian-prantl

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

@@ -14,7 +14,7 @@
 
 #include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
-#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
+#include "Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Target/Process.h"
@@ -23,9 +23,6 @@
 // FIXME: we should not need this
 #include "Plugins/Language/ObjC/Cocoa.h"
 
-#include "swift/AST/ASTContext.h"
-#include "llvm/ADT/StringRef.h"
-
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
@@ -283,7 +280,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(""));
 
@@ -327,22 +327,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/Language/Swift/SwiftMetatype.cpp

@@ -1,8 +1,8 @@
-//===-- SwiftMetatype.cpp ---------------------------------------*- C++ -*-===//
+//===-- SwiftMetatype.cpp -------------------------------------------------===//
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2016 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2023 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
@@ -12,12 +12,7 @@
 
 #include "SwiftMetatype.h"
 #include "Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h"
-#include "lldb/Core/Mangled.h"
 #include "lldb/Symbol/CompilerType.h"
-#include "lldb/Target/Process.h"
-
-#include "swift/AST/Type.h"
-#include "swift/AST/Types.h"
 
 using namespace lldb;
 using namespace lldb_private;
@@ -26,30 +21,18 @@ using namespace lldb_private::formatters::swift;
 
 bool lldb_private::formatters::swift::SwiftMetatype_SummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
+  ConstString name;
   lldb::addr_t metadata_ptr = valobj.GetPointerValue();
   if (metadata_ptr == LLDB_INVALID_ADDRESS || metadata_ptr == 0) {
     CompilerType compiler_metatype_type(valobj.GetCompilerType());
     CompilerType instancetype =
       TypeSystemSwift::GetInstanceType(compiler_metatype_type);
-
-    const char *ptr = instancetype.GetDisplayTypeName().AsCString(nullptr);
-    if (ptr && *ptr) {
-      stream.Printf("%s", ptr);
-      return true;
-    }
-  } else {
-    auto swift_runtime = SwiftLanguageRuntime::Get(valobj.GetProcessSP());
-    if (!swift_runtime)
-      return false;
-    SwiftLanguageRuntime::MetadataPromiseSP metadata_promise_sp =
-      swift_runtime->GetMetadataPromise(metadata_ptr, valobj);
-    if (!metadata_promise_sp)
-      return false;
-    if (CompilerType resolved_type =
-            metadata_promise_sp->FulfillTypePromise()) {
-      stream.Printf("%s", resolved_type.GetDisplayTypeName().AsCString());
-      return true;
-    }
+    name = instancetype.GetDisplayTypeName();
+  } else if (CompilerType meta_type = valobj.GetCompilerType()) {
+    name = meta_type.GetDisplayTypeName();
   }
-  return false;
+  if (!name)
+    return false;
+  stream << name;
+  return true;
 }

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

@@ -267,8 +267,7 @@ class SwiftLanguageRuntimeStub {
     return addr;
   }
 
-  SwiftLanguageRuntime::MetadataPromiseSP
-  GetMetadataPromise(lldb::addr_t addr, ValueObject &for_object) {
+  CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address addr) {
     STUB_LOG();
     return {};
   }
@@ -2382,10 +2381,9 @@ lldb::addr_t SwiftLanguageRuntime::FixupAddress(lldb::addr_t addr,
   FORWARD(FixupAddress, addr, type, error);
 }
 
-SwiftLanguageRuntime::MetadataPromiseSP
-SwiftLanguageRuntime::GetMetadataPromise(lldb::addr_t addr,
-                                         ValueObject &for_object) {
-  FORWARD(GetMetadataPromise, addr, for_object);
+CompilerType SwiftLanguageRuntime::GetTypeFromMetadata(TypeSystemSwift &tss,
+                                                       Address addr) {
+  FORWARD(GetTypeFromMetadata, tss, addr);
 }
 
 bool SwiftLanguageRuntime::IsStoredInlineInBuffer(CompilerType type) {

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

@@ -74,9 +74,6 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   std::unique_ptr<SwiftLanguageRuntimeImpl> m_impl;
 
 public:
-  class MetadataPromise;
-  typedef std::shared_ptr<MetadataPromise> MetadataPromiseSP;
-
   static char ID;
 
   bool isA(const void *ClassID) const override {
@@ -238,24 +235,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   CompilerType GetConcreteType(ExecutionContextScope *exe_scope,
                                ConstString abstract_type_name) override;
 
-  /// A proxy object to support lazy binding of Archetypes.
-  class MetadataPromise {
-    friend class SwiftLanguageRuntimeImpl;
-
-    MetadataPromise(ValueObject &, SwiftLanguageRuntimeImpl &, lldb::addr_t);
-
-    lldb::ValueObjectSP m_for_object_sp;
-    SwiftLanguageRuntimeImpl &m_swift_runtime;
-    lldb::addr_t m_metadata_location;
-    llvm::Optional<swift::MetadataKind> m_metadata_kind;
-    llvm::Optional<CompilerType> m_compiler_type;
-
-  public:
-    CompilerType FulfillTypePromise(Status *error = nullptr);
-  };
-
-  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

@@ -472,14 +472,14 @@ void SwiftLanguageRuntimeImpl::PopLocalBuffer() {
   ((LLDBMemoryReader *)GetMemoryReader().get())->popLocalBuffer();
 }
 
-SwiftLanguageRuntime::MetadataPromise::MetadataPromise(
+SwiftLanguageRuntimeImpl::MetadataPromise::MetadataPromise(
     ValueObject &for_object, SwiftLanguageRuntimeImpl &runtime,
     lldb::addr_t location)
     : m_for_object_sp(for_object.GetSP()), m_swift_runtime(runtime),
       m_metadata_location(location) {}
 
 CompilerType
-SwiftLanguageRuntime::MetadataPromise::FulfillTypePromise(Status *error) {
+SwiftLanguageRuntimeImpl::MetadataPromise::FulfillTypePromise(Status *error) {
   if (error)
     error->Clear();
 
@@ -532,7 +532,7 @@ SwiftLanguageRuntime::MetadataPromise::FulfillTypePromise(Status *error) {
   }
 }
 
-SwiftLanguageRuntime::MetadataPromiseSP
+SwiftLanguageRuntimeImpl::MetadataPromiseSP
 SwiftLanguageRuntimeImpl::GetMetadataPromise(lldb::addr_t addr,
                                              ValueObject &for_object) {
   llvm::Optional<SwiftScratchContextReader> maybe_swift_scratch_ctx =
@@ -555,8 +555,8 @@ SwiftLanguageRuntimeImpl::GetMetadataPromise(lldb::addr_t addr,
   if (iter != m_promises_map.end())
     return iter->second;
 
-  SwiftLanguageRuntime::MetadataPromiseSP promise_sp(
-      new SwiftLanguageRuntime::MetadataPromise(for_object, *this, addr));
+  SwiftLanguageRuntimeImpl::MetadataPromiseSP promise_sp(
+      new SwiftLanguageRuntimeImpl::MetadataPromise(for_object, *this, addr));
   m_promises_map.insert({key, promise_sp});
   return promise_sp;
 }
@@ -2284,6 +2284,65 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Protocol(
   return true;
 }
 
+bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_ExistentialMetatype(
+    ValueObject &in_value, CompilerType meta_type,
+    lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
+    Address &address) {
+  // Resolve the dynamic type of the metatype.
+  AddressType address_type;
+  lldb::addr_t ptr = in_value.GetPointerValue(&address_type);
+  if (ptr == LLDB_INVALID_ADDRESS || ptr == 0)
+    return false;
+
+  ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
+  if (!reflection_ctx)
+    return false;
+
+  const swift::reflection::TypeRef *type_ref =
+      reflection_ctx->readTypeFromMetadata(ptr);
+
+  auto tss = meta_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!tss)
+    return false;
+  auto &ts = tss->GetTypeSystemSwiftTypeRef();
+
+  using namespace swift::Demangle;
+  Demangler dem;
+  NodePointer node = type_ref->getDemangling(dem);
+  // Wrap the resolved type in a metatype again for the data formatter to
+  // recognize.
+  if (!node || node->getKind() != Node::Kind::Type)
+    return false;
+  NodePointer wrapped = dem.createNode(Node::Kind::Type);
+  NodePointer meta = dem.createNode(Node::Kind::Metatype);
+  meta->addChild(node, dem);
+  wrapped->addChild(meta,dem);
+
+  meta_type = ts.GetTypeSystemSwiftTypeRef().RemangleAsType(dem, wrapped);
+  class_type_or_name.SetCompilerType(meta_type);
+  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) {
@@ -2308,7 +2367,7 @@ SwiftLanguageRuntimeImpl::GetTypeMetadataForTypeNameAndFrame(
   return metadata_location;
 }
 
-  SwiftLanguageRuntime::MetadataPromiseSP
+SwiftLanguageRuntimeImpl::MetadataPromiseSP
 SwiftLanguageRuntimeImpl::GetPromiseForTypeNameAndFrame(const char *type_name,
                                                         StackFrame *frame) {
   if (!frame || !type_name || !type_name[0])
@@ -3161,11 +3220,16 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress(
         in_value, use_dynamic, class_type_or_name, address, static_value_type);
   else if (type_info.AnySet(eTypeIsPack))
     success = GetDynamicTypeAndAddress_Pack(in_value, val_type, use_dynamic,
-                                           class_type_or_name, address, static_value_type);
+                                            class_type_or_name, address,
+                                            static_value_type);
   else if (type_info.AnySet(eTypeIsClass) ||
            type_info.AllSet(eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue))
     success = GetDynamicTypeAndAddress_Class(in_value, val_type, use_dynamic,
-                                             class_type_or_name, address, static_value_type);
+                                             class_type_or_name, address,
+                                             static_value_type);
+  else if (type_info.AllSet(eTypeIsMetatype | eTypeIsProtocol))
+    success = GetDynamicTypeAndAddress_ExistentialMetatype(
+        in_value, val_type, use_dynamic, class_type_or_name, address);
   else if (type_info.AnySet(eTypeIsProtocol))
     success = GetDynamicTypeAndAddress_Protocol(in_value, val_type, use_dynamic,
                                                 class_type_or_name, address);
@@ -3498,7 +3562,7 @@ SwiftLanguageRuntimeImpl::GetConcreteType(ExecutionContextScope *exe_scope,
   if (!frame)
     return CompilerType();
 
-  SwiftLanguageRuntime::MetadataPromiseSP promise_sp(
+  SwiftLanguageRuntimeImpl::MetadataPromiseSP promise_sp(
       GetPromiseForTypeNameAndFrame(abstract_type_name.GetCString(), frame));
   if (!promise_sp)
     return CompilerType();

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

@@ -107,8 +107,7 @@ class SwiftLanguageRuntimeImpl {
   llvm::Optional<size_t> GetBitAlignment(CompilerType type,
                                          ExecutionContextScope *exe_scope);
 
-  SwiftLanguageRuntime::MetadataPromiseSP
-  GetMetadataPromise(lldb::addr_t addr, ValueObject &for_object);
+  CompilerType GetTypeFromMetadata(TypeSystemSwift &tss, Address address);
 
   llvm::Optional<uint64_t>
   GetMemberVariableOffsetRemoteAST(CompilerType instance_type,
@@ -322,6 +321,11 @@ class SwiftLanguageRuntimeImpl {
                                          TypeAndOrName &class_type_or_name,
                                          Address &address);
 
+  bool GetDynamicTypeAndAddress_ExistentialMetatype(
+      ValueObject &in_value, CompilerType meta_type,
+      lldb::DynamicValueType use_dynamic, TypeAndOrName &class_type_or_name,
+      Address &address);
+
   bool GetDynamicTypeAndAddress_Value(ValueObject &in_value,
                                       CompilerType &bound_type,
                                       lldb::DynamicValueType use_dynamic,
@@ -340,7 +344,26 @@ class SwiftLanguageRuntimeImpl {
                                           Address &address,
                                           Value::ValueType &value_type);
 
-  SwiftLanguageRuntime::MetadataPromiseSP
+  /// A proxy object to support lazy binding of Archetypes.
+  class MetadataPromise {
+    friend class SwiftLanguageRuntimeImpl;
+
+    MetadataPromise(ValueObject &, SwiftLanguageRuntimeImpl &, lldb::addr_t);
+
+    lldb::ValueObjectSP m_for_object_sp;
+    SwiftLanguageRuntimeImpl &m_swift_runtime;
+    lldb::addr_t m_metadata_location;
+    llvm::Optional<swift::MetadataKind> m_metadata_kind;
+    llvm::Optional<CompilerType> m_compiler_type;
+
+  public:
+    CompilerType FulfillTypePromise(Status *error = nullptr);
+  };
+  typedef std::shared_ptr<MetadataPromise> MetadataPromiseSP;
+
+  MetadataPromiseSP GetMetadataPromise(lldb::addr_t addr,
+                                       ValueObject &for_object);
+  MetadataPromiseSP
   GetPromiseForTypeNameAndFrame(const char *type_name, StackFrame *frame);
 
   llvm::Optional<lldb::addr_t>
@@ -371,7 +394,7 @@ class SwiftLanguageRuntimeImpl {
   std::shared_ptr<LLDBMemoryReader> m_memory_reader_sp;
 
   llvm::DenseMap<std::pair<swift::ASTContext *, lldb::addr_t>,
-                 SwiftLanguageRuntime::MetadataPromiseSP>
+                 MetadataPromiseSP>
       m_promises_map;
 
   llvm::DenseMap<swift::ASTContext *,