Merge pull request #10986 from augusto2112/cp-0601-change-remote-addr

Cherry pick [NFC][lldb] Adapt LLDB to RemoteInspection's RemoteAddress changes and others to rebranch

Author: augusto2112

lldb/packages/Python/lldbsuite/test/lldbtest.py

@@ -787,7 +787,7 @@ def setUpCommands(cls):
             ),
             # Enable expensive validations in TypeSystemSwiftTypeRef.
             "settings set symbols.swift-validate-typesystem true",
-            "settings set symbols.swift-typesystem-compiler-fallback true",
+            "settings set symbols.swift-typesystem-compiler-fallback false",
         ]
 
         # Set any user-overridden settings.

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionSourceCode.cpp

@@ -12,6 +12,7 @@
 
 #include "Plugins/ExpressionParser/Swift/SwiftASTManipulator.h"
 #include "Plugins/TypeSystem/Swift/SwiftASTContext.h"
+#include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
@@ -114,6 +115,56 @@ struct CallsAndArgs {
   std::string lldb_call;
 };
 
+static llvm::SmallVector<const SwiftASTManipulator::VariableInfo *>
+CollectMetadataVariables(
+    llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables) {
+  llvm::SmallVector<const SwiftASTManipulator::VariableInfo *>
+      metadata_variables;
+  for (auto &var : local_variables)
+    if (var.IsOutermostMetadataPointer())
+      metadata_variables.push_back(&var);
+  return metadata_variables;
+}
+
+struct MetadataInfo {
+  bool is_pack = false;
+  unsigned depth;
+  unsigned index;
+  llvm::StringRef archetype_name;
+
+  MetadataInfo(bool is_pack, unsigned depth, unsigned index, llvm::StringRef archetype_name)
+      : is_pack(is_pack), depth(depth), index(index), archetype_name(archetype_name) {}
+};
+
+static llvm::Expected<llvm::SmallVector<MetadataInfo>> CollectMetadataInfos(
+    llvm::ArrayRef<const SwiftASTManipulator::VariableInfo *>
+        metadata_variables,
+    const std::optional<SwiftLanguageRuntime::GenericSignature> &generic_sig) {
+  llvm::SmallVector<MetadataInfo> metadata_info;
+
+  for (size_t i = 0; i < metadata_variables.size(); ++i) {
+    auto variable_sp =
+        llvm::cast<SwiftASTManipulatorBase::VariableMetadataVariable>(
+            metadata_variables[i]->GetMetadata())
+            ->m_variable_sp;
+    auto archetype_name = variable_sp->GetType()->GetName();
+    if (generic_sig)
+      metadata_info.emplace_back(generic_sig->generic_params[i].is_pack,
+                                 generic_sig->generic_params[i].depth,
+                                 generic_sig->generic_params[i].index,
+                                 archetype_name);
+    else {
+      auto maybe_depth_and_index =
+          ParseSwiftGenericParameter(metadata_variables[i]->GetName().str());
+      if (!maybe_depth_and_index)
+        return llvm::createStringError(llvm::errc::not_supported,
+                                       "unexpected metadata variable");
+      metadata_info.emplace_back(false, maybe_depth_and_index->first,
+                                 maybe_depth_and_index->second, archetype_name);
+    }
+  }
+  return metadata_info;
+}
 /// Constructs the signatures for the expression evaluation functions based on
 /// the metadata variables in scope and any variadic functiontion parameters.
 /// For every outermost metadata pointer in scope ($τ_0_0, $τ_0_1, etc), we want
@@ -149,50 +200,35 @@ static llvm::Expected<CallsAndArgs> MakeGenericSignaturesAndCalls(
     llvm::ArrayRef<SwiftASTManipulator::VariableInfo> local_variables,
     const std::optional<SwiftLanguageRuntime::GenericSignature> &generic_sig,
     bool needs_object_ptr) {
-  llvm::SmallVector<const SwiftASTManipulator::VariableInfo *>
-      metadata_variables;
-  for (auto &var : local_variables)
-    if (var.IsOutermostMetadataPointer())
-      metadata_variables.push_back(&var);
-
+  auto metadata_variables = CollectMetadataVariables(local_variables);
   // The number of metadata variables could be > if the function is in
   // a generic context.
   if (generic_sig &&
       (metadata_variables.size() < generic_sig->dependent_generic_param_count))
     return llvm::createStringError(llvm::errc::not_supported,
                                    "Inconsistent generic signature");
 
+  auto maybe_metadata_infos = CollectMetadataInfos(metadata_variables, generic_sig);
+  if (!maybe_metadata_infos)
+    return maybe_metadata_infos.takeError();
+  auto metadata_infos = *maybe_metadata_infos;
+
   llvm::SmallDenseMap<std::pair<unsigned, unsigned>, llvm::SmallString<4>> subs;
   std::string generic_params;
   std::string generic_params_no_packs;
   llvm::raw_string_ostream s_generic_params(generic_params);
   llvm::raw_string_ostream s_generic_params_no_packs(generic_params_no_packs);
-  for (size_t i = 0; i < metadata_variables.size(); ++i) {
-    llvm::SmallString<4> archetype_name;
-    llvm::raw_svector_ostream s_archetype_name(archetype_name);
-    bool is_pack = false;
-    unsigned depth, index;
-    if (generic_sig) {
-      auto &gp = generic_sig->generic_params[i];
-      is_pack = gp.is_pack;
-      depth = gp.depth;
-      index = gp.index;
-    } else {
-      auto di =
-          ParseSwiftGenericParameter(metadata_variables[i]->GetName().str());
-      if (!di)
-        return llvm::createStringError(llvm::errc::not_supported,
-                                       "unexpected metadata variable");
-      depth = di->first;
-      index = di->second;
-    }
+
+  for (auto &[is_pack, depth, index, archetype_name] : metadata_infos) {
+    llvm::SmallString<4> sig_archetype_name;
+    llvm::raw_svector_ostream s_sig_archetype_name(sig_archetype_name);
     if (is_pack)
-      s_archetype_name << "each ";
-    s_archetype_name << "T" << i;
+      s_sig_archetype_name << "each ";
+    s_sig_archetype_name << archetype_name;
     if (!is_pack)
-      s_generic_params_no_packs << archetype_name << ",";
-    subs.insert({{depth, index}, archetype_name});
-    s_generic_params << archetype_name << ",";
+      s_generic_params_no_packs << sig_archetype_name << ",";
+    s_generic_params << sig_archetype_name << ",";
+    subs.insert({{depth, index}, sig_archetype_name});
   }
 
   if (!generic_params.empty())

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

@@ -745,9 +745,9 @@ class EnumSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
   llvm::Expected<size_t> GetIndexOfChildWithName(ConstString name) override;
 
 private:
-  ExecutionContextRef m_exe_ctx_ref;
-  ConstString m_element_name;
-  size_t m_child_index;
+  ValueObjectSP m_projected;
+  lldb::DynamicValueType m_dynamic = eNoDynamicValues;
+  bool m_indirect = false;
 };
 
 static std::string mangledTypenameForTasksTuple(size_t count) {
@@ -1516,50 +1516,83 @@ class ActorSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::EnumSyntheticFrontEnd(
     lldb::ValueObjectSP valobj_sp)
-    : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_exe_ctx_ref(),
-      m_element_name(nullptr), m_child_index(UINT32_MAX) {
+    : SyntheticChildrenFrontEnd(*valobj_sp.get()) {
   if (valobj_sp)
     Update();
 }
 
 llvm::Expected<uint32_t>
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::CalculateNumChildren() {
-  return m_child_index != UINT32_MAX ? 1 : 0;
+  if (m_indirect && m_projected)
+    return m_projected->GetNumChildren();
+  return m_projected ? 1 : 0;
 }
 
 lldb::ValueObjectSP
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::GetChildAtIndex(
     uint32_t idx) {
-  if (idx)
-    return ValueObjectSP();
-  if (m_child_index == UINT32_MAX)
-    return ValueObjectSP();
-  return m_backend.GetChildAtIndex(m_child_index, true);
+  ValueObjectSP value_sp;
+  // Hide the indirection.
+  if (m_indirect && m_projected) {
+    value_sp = m_projected->GetChildAtIndex(idx);
+  } else {
+    if (idx != 0)
+      return {};
+    value_sp = m_projected;
+  }
+  if (!value_sp)
+    return {};
+
+  return value_sp;
 }
 
 lldb::ChildCacheState
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::Update() {
-  m_element_name.Clear();
-  m_child_index = UINT32_MAX;
-  m_exe_ctx_ref = m_backend.GetExecutionContextRef();
-  m_element_name.SetCString(m_backend.GetValueAsCString());
-  auto index_or_err = m_backend.GetIndexOfChildWithName(m_element_name);
-  if (!index_or_err)
-    llvm::consumeError(index_or_err.takeError());
+  auto *runtime = SwiftLanguageRuntime::Get(m_backend.GetProcessSP());
+  if (!runtime)
+    return ChildCacheState::eRefetch;
+
+  llvm::Expected<ValueObjectSP> projected =
+      runtime->SwiftLanguageRuntime::ProjectEnum(m_backend);
+  if (!projected) {
+    LLDB_LOG_ERROR(GetLog(LLDBLog::DataFormatters), projected.takeError(),
+                   "{0}");
+    return ChildCacheState::eRefetch;
+  }
+
+  m_dynamic = m_backend.GetDynamicValueType();
+  m_projected = *projected;
+  if (m_projected &&
+      m_projected->GetName().GetStringRef().starts_with("$indirect."))
+    m_indirect = true;
   else
-    m_child_index = *index_or_err;
+    m_indirect = false;
+
+  if (!m_projected)
+    return ChildCacheState::eRefetch;
+
+  if ((m_projected->GetCompilerType().GetTypeInfo() & eTypeIsEnumeration))
+    if (auto synthetic_sp = m_projected->GetSyntheticValue())
+      m_projected = synthetic_sp;
+
+  if (m_dynamic != eNoDynamicValues)
+    if (auto dynamic_sp = m_projected->GetDynamicValue(m_dynamic))
+      m_projected = dynamic_sp;
   return ChildCacheState::eRefetch;
 }
 
 bool lldb_private::formatters::swift::EnumSyntheticFrontEnd::
     MightHaveChildren() {
-  return m_child_index != UINT32_MAX;
+  return m_projected ? true : false;
 }
 
 llvm::Expected<size_t>
 lldb_private::formatters::swift::EnumSyntheticFrontEnd::GetIndexOfChildWithName(
     ConstString name) {
-  if (name == m_element_name)
+  // Hide the indirection.
+  if (m_indirect && m_projected)
+    return m_projected->GetIndexOfChildWithName(name);
+  if (m_projected && name == m_projected->GetName())
     return 0;
   return llvm::createStringError("Type has no child named '%s'",
                                  name.AsCString());

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

@@ -522,9 +522,9 @@ static void LoadSwiftFormatters(lldb::TypeCategoryImplSP swift_category_sp) {
 
   TypeSummaryImpl::Flags optional_summary_flags;
   optional_summary_flags.SetCascades(true)
-      .SetDontShowChildren(false) // this one will actually be calculated at
-                                  // runtime, what you pass here doesn't matter
-      .SetDontShowValue(true)
+      .SetDontShowChildren(true) // this one will actually be calculated at
+                                 // runtime, what you pass here doesn't matter
+      .SetDontShowValue(false)
       .SetHideItemNames(false)
       .SetShowMembersOneLiner(false)
       .SetSkipPointers(true)
@@ -974,10 +974,6 @@ SwiftLanguage::GetHardcodedSynthetics() {
       CompilerType type(valobj.GetCompilerType());
       Flags type_flags(type.GetTypeInfo());
       if (type_flags.AllSet(eTypeIsSwift | eTypeIsEnumeration)) {
-        // FIXME: The classification of clang-imported enums may
-        // change based on whether a Swift module is present or not.
-        if (!valobj.GetValueAsCString())
-          return nullptr;
         if (!swift_enum_synth)
           swift_enum_synth = lldb::SyntheticChildrenSP(new CXXSyntheticChildren(
               SyntheticChildren::Flags()

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

@@ -204,15 +204,16 @@ bool lldb_private::formatters::swift::SwiftOptionSetSummaryProvider::
     }
   }
 
-  if (!any_match)
-    return false;
-
   if (matched_value != value) {
     // Print the unaccounted-for bits separately.
     llvm::APInt residual = value & ~matched_value;
     llvm::SmallString<24> string;
     residual.toString(string, 16, false);
-    ss << ", 0x" << string;
+    if (any_match)
+      ss << ", ";
+    else
+      ss << "rawValue = ";
+    ss << "0x" << string;
   }
   ss << ']';