[LLDB] Add support for Dictionary in embedded Swift

Author: adrian-prantl

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

@@ -582,6 +582,10 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   llvm::Expected<const swift::reflection::TypeRef &>
   GetTypeRef(CompilerType type, TypeSystemSwiftTypeRef *module_holder);
 
+  /// Returns a non-null type system or an error.
+  static llvm::Expected<TypeSystemSwiftTypeRefSP>
+  GetReflectionTypeSystem(CompilerType for_type, ExecutionContext exe_ctx);
+
   /// Ask Remote Mirrors for the type info about a Swift type.
   /// This will return a nullptr if the lookup fails.
   llvm::Expected<const swift::reflection::TypeInfo &>

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

@@ -32,6 +32,7 @@
 #include "lldb/ValueObject/ValueObjectCast.h"
 #include "lldb/ValueObject/ValueObjectMemory.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/Casting.h"
 
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/ASTMangler.h"
@@ -791,11 +792,11 @@ SwiftRuntimeTypeVisitor::VisitImpl(std::optional<unsigned> visit_only,
 
   const unsigned success = 0;
   bool count_only = !visit_callback;
-  auto ts_sp =
-      m_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwiftTypeRef>();
-  if (!ts_sp)
-    return llvm::createStringError("no type system");
-  auto &ts = *ts_sp;
+  auto ts_or_err =
+      SwiftLanguageRuntime::GetReflectionTypeSystem(m_type, m_exe_ctx);
+  if (!ts_or_err)
+    return ts_or_err.takeError();
+  auto &ts = *ts_or_err->get();
 
   // Deal with the LLDB-only SILPackType variant.
   if (auto pack_type_info = ts.IsSILPackType(m_type)) {
@@ -3383,6 +3384,42 @@ SwiftLanguageRuntime::GetTypeRef(CompilerType type,
   return type_ref_or_err;
 }
 
+llvm::Expected<TypeSystemSwiftTypeRefSP>
+SwiftLanguageRuntime::GetReflectionTypeSystem(CompilerType for_type,
+                                              ExecutionContext exe_ctx) {
+  auto ts_sp = for_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!ts_sp)
+    return llvm::createStringError("not a Swift type");
+
+  // The TypeSystemSwiftTypeRefForExpressions doesn't have a SymbolFile,
+  // so any DWARF lookups for Embedded Swift fail.
+  //
+  // FIXME: It's unclear whether this is safe to do in a non-LTO Swift program.
+  if (auto *tr_ts =
+          llvm::dyn_cast_or_null<TypeSystemSwiftTypeRefForExpressions>(
+              ts_sp.get())) {
+    if (tr_ts->GetManglingFlavor(&exe_ctx) ==
+        swift::Mangle::ManglingFlavor::Embedded) {
+      if (auto *frame = exe_ctx.GetFramePtr()) {
+        auto &sc = frame->GetSymbolContext(eSymbolContextModule);
+        if (sc.module_sp) {
+          auto ts_or_err =
+              sc.module_sp->GetTypeSystemForLanguage(eLanguageTypeSwift);
+          if (!ts_or_err)
+            return ts_or_err.takeError();
+          if (auto *tr_ts =
+                  llvm::dyn_cast_or_null<TypeSystemSwift>(ts_or_err->get()))
+            ts_sp = tr_ts->GetTypeSystemSwiftTypeRef();
+        }
+      }
+    }
+  }
+  auto tr_ts = ts_sp->GetTypeSystemSwiftTypeRef();
+  if (!tr_ts)
+    return llvm::createStringError("no Swift typesystem");
+  return tr_ts;
+}
+
 llvm::Expected<const swift::reflection::TypeInfo &>
 SwiftLanguageRuntime::GetSwiftRuntimeTypeInfo(
     CompilerType type, ExecutionContextScope *exe_scope,
@@ -3393,14 +3430,17 @@ SwiftLanguageRuntime::GetSwiftRuntimeTypeInfo(
              "[SwiftLanguageRuntime::GetSwiftRuntimeTypeInfo] Getting "
              "type info for type: {0}",
              type.GetMangledTypeName());
-
-  auto ts_sp = type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
-  if (!ts_sp)
-    return llvm::createStringError("not a Swift type");
-  auto tr_ts = ts_sp->GetTypeSystemSwiftTypeRef();
-  if (!tr_ts)
-    return llvm::createStringError("no Swift typesystem");
-  auto &ts = *tr_ts;
+  StackFrame *frame = nullptr;
+  ExecutionContext exe_ctx;
+  if (exe_scope) {
+    frame = exe_scope->CalculateStackFrame().get();
+    if (frame)
+      frame->CalculateExecutionContext(exe_ctx);
+  }
+  auto ts_or_err = GetReflectionTypeSystem(type, exe_ctx);
+  if (!ts_or_err)
+    return ts_or_err.takeError();
+  auto &ts = *ts_or_err->get();
 
   // Resolve all type aliases.
   type = type.GetCanonicalType();
@@ -3414,15 +3454,13 @@ SwiftLanguageRuntime::GetSwiftRuntimeTypeInfo(
   // Resolve all generic type parameters in the type for the current
   // frame. Generic parameter binding has to happen in the scratch
   // context.
-  ExecutionContext exe_ctx;
-  if (exe_scope)
-    if (StackFrame *frame = exe_scope->CalculateStackFrame().get()) {
-      frame->CalculateExecutionContext(exe_ctx);
-      auto bound_type_or_err = BindGenericTypeParameters(*frame, type);
-      if (!bound_type_or_err)
-        return bound_type_or_err.takeError();
-      type = *bound_type_or_err;
-    }
+  if (frame) {
+    frame->CalculateExecutionContext(exe_ctx);
+    auto bound_type_or_err = BindGenericTypeParameters(*frame, type);
+    if (!bound_type_or_err)
+      return bound_type_or_err.takeError();
+    type = *bound_type_or_err;
+  }
 
   // BindGenericTypeParameters imports the type into the scratch
   // context, but we need to resolve (any DWARF links in) the typeref
@@ -3438,33 +3476,9 @@ SwiftLanguageRuntime::GetSwiftRuntimeTypeInfo(
   if (!reflection_ctx)
     return llvm::createStringError("no reflection context");
 
-  // The TypeSystemSwiftTypeRefForExpressions doesn't ve a SymbolFile,
-  // so any DWARF lookups for Embedded Swift fail.
-  //
-  // FIXME: It's unclear whether this is safe to do in a non-LTO Swift program.
-  if (llvm::isa<TypeSystemSwiftTypeRefForExpressions>(tr_ts.get()) &&
-      tr_ts->GetManglingFlavor(&exe_ctx) ==
-          swift::Mangle::ManglingFlavor::Embedded) {
-    if (auto frame_sp = exe_ctx.GetFrameSP()) {
-      auto &sc = frame_sp->GetSymbolContext(eSymbolContextModule);
-      if (sc.module_sp) {
-        auto ts_or_err =
-            sc.module_sp->GetTypeSystemForLanguage(eLanguageTypeSwift);
-        if (!ts_or_err)
-          return ts_or_err.takeError();
-        if (auto *tr_ts = llvm::dyn_cast_or_null<TypeSystemSwiftTypeRef>(
-                ts_or_err->get())) {
-          LLDBTypeInfoProvider provider(*this, *tr_ts);
-          return reflection_ctx->GetTypeInfo(*type_ref_or_err, &provider,
-                                             tr_ts->GetDescriptorFinder());
-        }
-      }
-    }
-  }
-
   LLDBTypeInfoProvider provider(*this, ts);
   return reflection_ctx->GetTypeInfo(*type_ref_or_err, &provider,
-                                     tr_ts->GetDescriptorFinder());
+                                     ts.GetDescriptorFinder());
 }
 
 bool SwiftLanguageRuntime::IsStoredInlineInBuffer(CompilerType type) {

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserSwiftDescriptorFinder.cpp

@@ -160,6 +160,12 @@ getTypeAndDie(TypeSystemSwiftTypeRef &ts,
   if (!dwarf)
     return {};
   TypeSP lldb_type = ts.FindTypeInModule(type.GetOpaqueQualType());
+  if (!lldb_type) {
+    if (ts.ContainsBoundGenericType(type.GetOpaqueQualType())) {
+      CompilerType generic_type = ts.MapOutOfContext(type.GetOpaqueQualType());
+      lldb_type = ts.FindTypeInModule(generic_type.GetOpaqueQualType());
+    }
+  }
   if (!lldb_type) {
     std::tie(lldb_type, type) = DWARFASTParserSwift::ResolveTypeAlias(type);
     if (lldb_type) {

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

@@ -1267,6 +1267,91 @@ CompilerType TypeSystemSwiftTypeRef::ApplySubstitutions(
   return RemangleAsType(dem, type_node, flavor);
 }
 
+CompilerType
+TypeSystemSwiftTypeRef::MapOutOfContext(lldb::opaque_compiler_type_t type) {
+  using namespace swift::Demangle;
+  Demangler dem;
+  const char *mangled_typename = AsMangledName(type);
+  auto flavor = SwiftLanguageRuntime::GetManglingFlavor(mangled_typename);
+  NodePointer type_node =
+      swift_demangle::GetDemangledTypeMangling(dem, mangled_typename);
+  if (!type_node)
+    return {};
+
+  // First perform a pre-order traversal to record the depths of the type
+  // parameters.
+  bool error = false;
+  unsigned depth = 0;
+  using ParamVector = llvm::SmallVector<std::pair<unsigned, unsigned>, 4>;
+  llvm::SmallDenseMap<NodePointer, ParamVector, 8> subs;
+  PreOrderTraversal(type_node, [&](NodePointer node) {
+    switch (node->getKind()) {
+    case Node::Kind::BoundGenericClass:
+    case Node::Kind::BoundGenericEnum:
+    case Node::Kind::BoundGenericFunction:
+    case Node::Kind::BoundGenericProtocol:
+    case Node::Kind::BoundGenericOtherNominalType:
+    case Node::Kind::BoundGenericStructure:
+    case Node::Kind::BoundGenericTypeAlias: {
+      if (node->getNumChildren() != 2) {
+        error = true;
+        return false;
+      }
+      NodePointer type_list =
+          swift_demangle::NodeAtPath(node->getChild(1), {Node::Kind::TypeList});
+      if (!type_list) {
+        error = true;
+        return false;
+      }
+      unsigned i = 0;
+      auto it = subs.insert({node, {}});
+      if (!it.second) {
+        error = true;
+        return false;
+      }
+      ParamVector &types = it.first->second;
+      for (NodePointer type : *type_list)
+        if (type && type->getKind() == Node::Kind::Type)
+          types.push_back({depth, i++});
+
+      depth += 1;
+
+      return true;
+    }
+    default:
+      return true;
+    }
+  });
+  if (error)
+    return {};
+
+  // Now perform a post-order traversal to substitute the nodes with the right
+  // depth.
+  type_node = Transform(dem, type_node, [&](NodePointer node) -> NodePointer {
+    auto it = subs.find(node);
+    if (it == subs.end())
+      return node;
+    ParamVector &types = it->second;
+    NodePointer remapped = dem.createNode(node->getKind());
+    remapped->addChild(node->getChild(0), dem);
+    NodePointer type_list = dem.createNode(Node::Kind::TypeList);
+    remapped->addChild(type_list, dem);
+    for (auto &type : types) {
+      NodePointer dgpt = dem.createNode(Node::Kind::DependentGenericParamType);
+      dgpt->addChild(dem.createNode(Node::Kind::Index, type.first), dem);
+      dgpt->addChild(dem.createNode(Node::Kind::Index, type.second), dem);
+      type_list->addChild(dgpt, dem);
+    }
+    for (auto &constraint : *node->getChild(1))
+      if (constraint->getKind() != Node::Kind::Type)
+        type_list->addChild(constraint, dem);
+
+    return remapped;
+  });
+
+  return RemangleAsType(dem, type_node, flavor);
+}
+
 bool TypeSystemSwiftTypeRef::IsBoundGenericAliasType(
     lldb::opaque_compiler_type_t type) {
   using namespace swift::Demangle;
@@ -1283,6 +1368,39 @@ bool TypeSystemSwiftTypeRef::IsBoundGenericAliasType(
   return node->getKind() == Node::Kind::BoundGenericTypeAlias;
 }
 
+static bool ContainsBoundGenericTypeNode(swift::Demangle::NodePointer node) {
+  if (!node)
+    return false;
+  switch (node->getKind()) {
+  case Node::Kind::BoundGenericClass:
+  case Node::Kind::BoundGenericEnum:
+  case Node::Kind::BoundGenericFunction:
+  case Node::Kind::BoundGenericProtocol:
+  case Node::Kind::BoundGenericOtherNominalType:
+  case Node::Kind::BoundGenericTypeAlias:
+  case Node::Kind::BoundGenericStructure:
+    return true;
+  default:
+    if (NodePointer parent = GetParentNode(node))
+      return ContainsBoundGenericTypeNode(parent);
+    return false;
+  }
+}
+
+bool TypeSystemSwiftTypeRef::ContainsBoundGenericType(
+    lldb::opaque_compiler_type_t type) {
+  using namespace swift::Demangle;
+  Demangler dem;
+  const char *mangled_typename = AsMangledName(type);
+
+  NodePointer node =
+      swift_demangle::GetDemangledTypeMangling(dem, mangled_typename);
+  if (!node || node->getKind() != Node::Kind::Type || !node->hasChildren())
+    return false;
+  node = node->getChild(0);
+  return ContainsBoundGenericTypeNode(node);
+}
+
 std::optional<TypeSystemSwift::TupleElement>
 TypeSystemSwiftTypeRef::GetTupleElement(lldb::opaque_compiler_type_t type,
                                         size_t idx) {
@@ -2632,7 +2750,9 @@ TypeSystemSwiftTypeRef::FindTypeInModule(opaque_compiler_type_t opaque_type) {
 
   TypeResults results;
   M->FindTypes(query, results);
-  return results.GetFirstType();
+  if (results.Done(query))
+    return results.GetFirstType();
+  return {};
 }
 
 // Tests

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

@@ -140,9 +140,13 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
 
   CompilerType GetParentType(lldb::opaque_compiler_type_t type);
   std::vector<std::vector<CompilerType>>
+  /// Extract the substitutions from a bound generic type.
   GetSubstitutions(lldb::opaque_compiler_type_t type);
+  /// Apply substitutions to a bound generic type that is mapped out of context.
   CompilerType ApplySubstitutions(lldb::opaque_compiler_type_t type,
                                   std::vector<std::vector<CompilerType>> subs);
+  /// Apply substitutions to a bound generic type that is mapped out of context.
+  CompilerType MapOutOfContext(lldb::opaque_compiler_type_t type);
 
   Module *GetModule() const { return m_module; }
 
@@ -366,6 +370,7 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
   /// Determine whether \p type is a protocol.
   bool IsExistentialType(lldb::opaque_compiler_type_t type);
   bool IsBoundGenericAliasType(lldb::opaque_compiler_type_t type);
+  bool ContainsBoundGenericType(lldb::opaque_compiler_type_t type);
 
   /// Recursively transform the demangle tree starting a \p node by
   /// doing a post-order traversal and replacing each node with
@@ -389,6 +394,7 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
 
   /// A left-to-right preorder traversal. Don't visit children if
   /// visitor returns false.
+  /// The NodePointer passed to \p fn is guaranteed to be non-null.
   static void
   PreOrderTraversal(swift::Demangle::NodePointer node,
                     std::function<bool(swift::Demangle::NodePointer)>);

lldb/test/API/lang/swift/embedded/frame_variable/TestSwiftEmbeddedFrameVariable.py

@@ -3,7 +3,6 @@
 from lldbsuite.test.decorators import *
 import lldbsuite.test.lldbutil as lldbutil
 
-@skipIf(bugnumber = "rdar://159531308")
 class TestSwiftEmbeddedFrameVariable(TestBase):
 
     @skipUnlessDarwin
@@ -32,7 +31,7 @@ def implementation(self, ast):
         if self.TraceOn():
             self.expect("log enable lldb types")
             self.expect("frame variable")
- 
+
         alias1 = frame.FindVariable("alias1")
         field = alias1.GetChildMemberWithName("t")
         lldbutil.check_variable(self, field, False, value='1')
@@ -262,3 +261,6 @@ def implementation(self, ast):
 
         string = frame.FindVariable("string")
         lldbutil.check_variable(self, string, False, summary='"Hello"')
+
+        dictionary = frame.FindVariable("dict")
+        lldbutil.check_variable(self, dictionary, False, summary='4 key/value pairs')

lldb/test/API/lang/swift/embedded/frame_variable/main.swift

@@ -194,6 +194,7 @@ func g() {
     let functionType = FunctionType()
     let innerFunctionType = InnerFunctionType()
     var inlineArray: InlineArray<4, Int> = [1, 2, 3, 4]
+    var dict: Dictionary<Int, Int> = [1:4, 2:3, 3:2, 4:1]
 
     let dummy = A() 
     let string = StaticString("Hello")