Merge pull request #7380 from adrian-prantl/cherry-pick-next

Cherry pick next

Author: adrian-prantl

lldb/source/Core/ValueObjectDynamicValue.cpp

@@ -22,10 +22,6 @@
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-types.h"
 
-#ifdef LLDB_ENABLE_SWIFT
-#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
-#endif // LLDB_ENABLE_SWIFT
-
 #include <cstring>
 #include <optional>
 namespace lldb_private {
@@ -456,7 +452,7 @@ bool ValueObjectDynamicValue::DynamicValueTypeInfoNeedsUpdate() {
 
   if (!scratch_ctx || !cached_ctx)
     return true;
-  return cached_ctx.GetSharedPointer().get() != scratch_ctx->get();
+  return (void*)cached_ctx.GetSharedPointer().get() != (void*)scratch_ctx->get();
 #else // !LLDB_ENABLE_SWIFT
   return false;
 #endif // LLDB_ENABLE_SWIFT

lldb/source/Expression/Materializer.cpp

@@ -25,11 +25,6 @@
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/lldb-forward.h"
 
-#ifdef LLDB_ENABLE_SWIFT
-#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
-#include "Plugins/ExpressionParser/Swift/SwiftPersistentExpressionState.h"
-#endif //LLDB_ENABLE_SWIFT
-
 #include <memory>
 #include <optional>
 
@@ -663,12 +658,6 @@ class EntityVariableBase : public Materializer::Entity {
 
       CompilerType valobj_type = valobj_sp->GetCompilerType();
 
-#ifdef LLDB_ENABLE_SWIFT
-      if (SwiftASTContext::IsGenericType(valobj_type)) {
-        valobj_sp = valobj_sp->GetDynamicValue(lldb::eDynamicDontRunTarget);
-      }
-#endif // LLDB_ENABLE_SWIFT
-
       lldb_private::DataExtractor data;
 
       Status extract_error;
@@ -1077,8 +1066,8 @@ class EntityResultVariable : public Materializer::Entity {
                                      "system: %s", status.AsCString());
         return;
       }
-      persistent_state =
-          target_sp->GetSwiftPersistentExpressionState(*exe_scope);
+      persistent_state = target_sp->GetPersistentExpressionStateForLanguage(
+          lldb::eLanguageTypeSwift);
 #endif // LLDB_ENABLE_SWIFT
     } else {
       auto type_system_or_err =

lldb/source/Expression/UserExpression.cpp

@@ -41,11 +41,6 @@
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 
-#ifdef LLDB_ENABLE_SWIFT
-#include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
-#include "Plugins/ExpressionParser/Swift/SwiftPersistentExpressionState.h"
-#endif //LLDB_ENABLE_SWIFT
-
 using namespace lldb_private;
 
 char UserExpression::ID;
@@ -438,18 +433,9 @@ UserExpression::Execute(DiagnosticManager &diagnostic_manager,
   lldb::ExpressionResults expr_result = DoExecute(
       diagnostic_manager, exe_ctx, options, shared_ptr_to_me, result_var);
   Target *target = exe_ctx.GetTargetPtr();
-  if (options.GetSuppressPersistentResult() && result_var && target) {
-#ifdef LLDB_ENABLE_SWIFT
-    if (m_language == lldb::eLanguageTypeSwift) {
-      if (auto *exe_scope = exe_ctx.GetBestExecutionContextScope())
-        if (auto *persistent_state =
-                target->GetSwiftPersistentExpressionState(*exe_scope))
-          persistent_state->RemovePersistentVariable(result_var);
-    } else
-#endif // LLDB_ENABLE_SWIFT
+  if (options.GetSuppressPersistentResult() && result_var && target)
     if (auto *persistent_state =
                    target->GetPersistentExpressionStateForLanguage(m_language))
       persistent_state->RemovePersistentVariable(result_var);
-  }
   return expr_result;
 }

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

@@ -13,6 +13,7 @@
 #include "SwiftLanguageRuntimeImpl.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
+#include "swift/Demangling/Demangle.h"
 
 using namespace lldb;
 using namespace lldb_private;
@@ -26,12 +27,14 @@ template <typename ReflectionContext>
 class TargetReflectionContext
     : public SwiftLanguageRuntimeImpl::ReflectionContextInterface {
   ReflectionContext m_reflection_ctx;
+  swift::reflection::TypeConverter m_type_converter;
 
 public:
   TargetReflectionContext(
       std::shared_ptr<swift::reflection::MemoryReader> reader,
       SwiftMetadataCache *swift_metadata_cache)
-      : m_reflection_ctx(reader, swift_metadata_cache) {}
+      : m_reflection_ctx(reader, swift_metadata_cache),
+        m_type_converter(m_reflection_ctx.getBuilder()) {}
 
   llvm::Optional<uint32_t> AddImage(
       llvm::function_ref<std::pair<swift::remote::RemoteRef<void>, uint64_t>(
@@ -55,6 +58,39 @@ class TargetReflectionContext
                                     likely_module_names);
   }
 
+  const swift::reflection::TypeRef *
+  GetTypeRefOrNull(StringRef mangled_type_name) override {
+    swift::Demangle::Demangler dem;
+    swift::Demangle::NodePointer node = dem.demangleSymbol(mangled_type_name);
+    const swift::reflection::TypeRef *type_ref = GetTypeRefOrNull(dem, node);
+    if (!type_ref)
+      LLDB_LOG(GetLog(LLDBLog::Types), "Could not find typeref for type: {0}",
+               mangled_type_name);
+    return type_ref;
+  }
+
+  virtual const swift::reflection::TypeRef *
+  GetTypeRefOrNull(swift::Demangle::Demangler &dem,
+                   swift::Demangle::NodePointer node) override {
+    auto type_ref_or_err =
+        swift::Demangle::decodeMangledType(m_reflection_ctx.getBuilder(), node);
+    if (type_ref_or_err.isError()) {
+      LLDB_LOG(GetLog(LLDBLog::Types),
+               "Could not find typeref: decode mangled type failed. Error: {0}",
+               type_ref_or_err.getError()->copyErrorString());
+      return nullptr;
+    }
+    return type_ref_or_err.getType();
+  }
+
+  const swift::reflection::TypeInfo *
+  GetClassInstanceTypeInfo(const swift::reflection::TypeRef *type_ref,
+                           swift::remote::TypeInfoProvider *provider) override {
+    if (!type_ref)
+      return nullptr;
+    return m_type_converter.getClassInstanceTypeInfo(type_ref, 0, provider);
+  }
+
   const swift::reflection::TypeInfo *
   GetTypeInfo(const swift::reflection::TypeRef *type_ref,
               swift::remote::TypeInfoProvider *provider) override {
@@ -95,6 +131,11 @@ class TargetReflectionContext
     return m_reflection_ctx.getReader();
   }
 
+  const swift::reflection::TypeRef *
+  LookupSuperclass(const swift::reflection::TypeRef *tr) override {
+    return m_reflection_ctx.getBuilder().lookupSuperclass(tr);
+  }
+
   bool ForEachSuperClassType(
       swift::remote::TypeInfoProvider *tip, lldb::addr_t pointer,
       std::function<bool(SwiftLanguageRuntimeImpl::SuperClassType)> fn)
@@ -160,18 +201,20 @@ class TargetReflectionContext
                                                  skip_artificial_subclasses);
   }
 
-  swift::reflection::TypeRefBuilder &GetBuilder() override {
-    return m_reflection_ctx.getBuilder();
-  }
-
   llvm::Optional<bool> IsValueInlinedInExistentialContainer(
       swift::remote::RemoteAddress existential_address) override {
     return m_reflection_ctx.isValueInlinedInExistentialContainer(
         existential_address);
   }
 
-  swift::remote::RemoteAbsolutePointer
-  StripSignedPointer(swift::remote::RemoteAbsolutePointer pointer) override {
+  const swift::reflection::TypeRef *ApplySubstitutions(
+      const swift::reflection::TypeRef *type_ref,
+      swift::reflection::GenericArgumentMap substitutions) override{
+    return type_ref->subst(m_reflection_ctx.getBuilder(), substitutions);
+  }
+
+  swift::remote::RemoteAbsolutePointer StripSignedPointer(
+      swift::remote::RemoteAbsolutePointer pointer) override {
     return m_reflection_ctx.stripSignedPointer(pointer);
   }
 };