Remove SwiftASTContext from SwiftMetatype_SummaryProvider

This is done primarily for performance reasons.
The change is not entirely NFC, the type produced by the reflection API is more verbose, but also more accurate.

(cherry picked from commit 763ecf6)

Author: adrian-prantl

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/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -1760,6 +1760,46 @@ 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;
+}
+  
 llvm::Optional<lldb::addr_t>
 SwiftLanguageRuntimeImpl::GetTypeMetadataForTypeNameAndFrame(
     StringRef mdvar_name, StackFrame &frame) {
@@ -2381,11 +2421,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);

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

@@ -352,6 +352,12 @@ class SwiftLanguageRuntimeImpl {
                                              bool use_local_buffer,
                                              lldb::addr_t existential_address);
 #endif
+
+  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,

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

@@ -705,6 +705,7 @@ std::string SwiftLanguageRuntime::DemangleSymbolAsString(
     options.ShowPrivateDiscriminators = false;
     options.DisplayExtensionContexts = false;
     options.DisplayLocalNameContexts = false;
+    options.ShowFunctionArgumentTypes = true;
     break;
   case eDisplayTypeName:
     options = swift::Demangle::DemangleOptions::SimplifiedUIDemangleOptions();
@@ -714,6 +715,7 @@ std::string SwiftLanguageRuntime::DemangleSymbolAsString(
     options.DisplayModuleNames = true;
     options.DisplayLocalNameContexts = false;
     options.DisplayDebuggerGeneratedModule = false;
+    options.ShowFunctionArgumentTypes = true;
     break;    
   }
 

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -5440,6 +5440,8 @@ SwiftASTContext::GetTypeInfo(opaque_compiler_type_t type,
     swift_flags |= eTypeHasChildren | eTypeIsStructUnion | eTypeIsProtocol;
     break;
   case swift::TypeKind::ExistentialMetatype:
+    swift_flags |= eTypeIsProtocol;
+    LLVM_FALLTHROUGH;
   case swift::TypeKind::Metatype:
     swift_flags |= eTypeIsMetatype | eTypeHasValue;
     break;

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp

@@ -1295,6 +1295,8 @@ TypeSystemSwiftTypeRef::CollectTypeInfo(swift::Demangle::Demangler &dem,
       break;
 
     case Node::Kind::ExistentialMetatype:
+      swift_flags |= eTypeIsProtocol;
+      LLVM_FALLTHROUGH;
     case Node::Kind::Metatype:
       swift_flags |= eTypeIsMetatype | eTypeHasValue;
       break;
@@ -3361,6 +3363,7 @@ bool TypeSystemSwiftTypeRef::IsExistentialType(
   if (!node || node->getNumChildren() != 1)
     return false;
   switch (node->getKind()) {
+  case Node::Kind::ExistentialMetatype:
   case Node::Kind::Protocol:
   case Node::Kind::ProtocolList:
     return true;

lldb/test/API/lang/swift/bridged_metatype/TestSwiftBridgedMetatype.py

@@ -25,7 +25,4 @@ def test_swift_bridged_metatype(self):
         )
 
         var_k = self.frame().FindVariable("k")
-        if sys.platform.startswith("linux"):
-            lldbutil.check_variable(self, var_k, False, "Foundation.NSString")
-        else:
-            lldbutil.check_variable(self, var_k, False, "NSString")
+        lldbutil.check_variable(self, var_k, False, "@thick NSString.Type")

lldb/test/API/lang/swift/metatype/TestSwiftMetatype.py

@@ -43,7 +43,7 @@ def test_metatype(self):
         var_t = frame.FindVariable("t")
         var_p = frame.FindVariable("p")
         lldbutil.check_variable(self, var_s, False, "String")
-        lldbutil.check_variable(self, var_c, False, "a.D")
-        lldbutil.check_variable(self, var_f, False, "(Int) -> Int")
+        lldbutil.check_variable(self, var_c, False, "@thick a.D.Type")
+        lldbutil.check_variable(self, var_f, False, '@thick ((Int) -> Int).Type')
         lldbutil.check_variable(self, var_t, False, "(Int, Int, String)")
         lldbutil.check_variable(self, var_p, False, "a.P")