[lldb] Implement identification of generic Swift types in C++

The mangled name generated for generic Swift types contain unbound
generics. Implement substituting those generic types in by consulting
the C++ generated type's templates, and recursively resolving those to
their Swift counterpart.

Author: augusto2112

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

@@ -733,6 +733,84 @@ SwiftLanguage::GetHardcodedSummaries() {
   return g_formatters;
 }
 
+static CompilerType
+ExtractSwiftTypeFromCxxInteropType(CompilerType type, TypeSystemSwift &ts,
+                                   SwiftLanguageRuntime &runtime) {
+  // Try to recognize a Swift type wrapped in a C++ interop wrapper class.
+  // These types have a typedef from a char to the swift mangled name, and a
+  // static constexpr char field whose type is the typedef, and whose name
+  // is __swift_mangled_name.
+  // These classes will look something like:
+  // class CxxBridgedClass {
+  //   [Layout specific variables]
+  //   typedef char $sClassMangledNameHere;
+  //   static inline constexpr $sClassMangledNameHere __swift_mangled_name = 0;
+  // }
+
+
+  Log *log(GetLog(LLDBLog::DataFormatters));
+  // This only makes sense for Clang types.
+  auto tsc = type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>();
+  if (!tsc)
+    return {};
+
+  // We operate directly on the qualified type because the TypeSystem
+  // interface doesn't allow us to check for static constexpr members.
+  auto qual_type = TypeSystemClang::GetQualType(type.GetOpaqueQualType());
+  auto *record_type =
+      llvm::dyn_cast_or_null<clang::RecordType>(qual_type.getTypePtrOrNull());
+  if (!record_type) {
+    LLDB_LOGV(log, "[ExtractSwiftTypeFromCxxInteropType] "
+                   "Type is not a record type.");
+    return {};
+  }
+
+  const clang::RecordDecl *record_decl = record_type->getDecl();
+  CompilerType swift_type;
+
+  for (auto *child_decl : record_decl->decls()) {
+    auto *var_decl = llvm::dyn_cast<clang::VarDecl>(child_decl);
+    if (!var_decl)
+      continue;
+
+    auto name = var_decl->getName();
+    if (name != "__swift_mangled_name")
+      continue;
+
+    const auto *typedef_type =
+        llvm::dyn_cast<clang::TypedefType>(var_decl->getType());
+    if (!typedef_type)
+      break;
+
+    auto *decl = typedef_type->getDecl();
+    if (!decl)
+      break;
+
+    auto swift_name = decl->getName();
+    if (!swift::Demangle::isMangledName(swift_name))
+      break;
+
+    swift_type = ts.GetTypeFromMangledTypename(ConstString(swift_name));
+    break;
+  }
+
+  if (swift_type) {
+    auto bound_type = runtime.BindGenericTypeParameters(
+        swift_type, [&](unsigned depth, unsigned index) -> CompilerType {
+          assert(depth == 0 && "Unexpected depth! C++ interop does not support "
+                               "nested generic parameters");
+          if (depth > 0)
+            return {};
+
+          auto templated_type = type.GetTypeTemplateArgument(index);
+          return ExtractSwiftTypeFromCxxInteropType(templated_type, ts,
+                                                    runtime);
+        });
+    return bound_type;
+  }
+  return {};
+}
+
 HardcodedFormatters::HardcodedSyntheticFinder
 SwiftLanguage::GetHardcodedSynthetics() {
   static std::once_flag g_initialize;
@@ -862,11 +940,6 @@ SwiftLanguage::GetHardcodedSynthetics() {
                               lldb::DynamicValueType dyn_type,
                               FormatManager &format_manager)
                                -> lldb::SyntheticChildrenSP {
-      // Try to recognize a Swift type wrapped in a C++ interop wrapper class.
-      // These types have a typedef from a char to the swift mangled name, and a
-      // static constexpr char field whose type is the typedef, and whose name
-      // is $__swift_mangled_name.
-
       Log *log(GetLog(LLDBLog::DataFormatters));
 
       ProcessSP process_sp(valobj.GetProcessSP());
@@ -885,56 +958,10 @@ SwiftLanguage::GetHardcodedSynthetics() {
       }
       auto &type_system_swift = **scratch_ctx;
 
-      // This only makes sense for Clang types.
       auto type = valobj.GetCompilerType();
-      auto tsc = type.GetTypeSystem().dyn_cast_or_null<TypeSystemClang>();
-      if (!tsc) {
-        LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
-                       "Type is not a clang type.");
-        return nullptr;
-      }
-
-      // We operate directly on the qualified type because the TypeSystem
-      // interface doesn't allow us to check for static constexpr members.
-      auto qual_type = TypeSystemClang::GetQualType(type.GetOpaqueQualType());
-      auto *record_type = llvm::dyn_cast_or_null<clang::RecordType>(
-          qual_type.getTypePtrOrNull());
-      if (!record_type) {
-        LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
-                       "Type is not a record type.");
-        return nullptr;
-      }
-
-      const clang::RecordDecl *record_decl = record_type->getDecl();
-      CompilerType swift_type;
-
-      for (auto *child_decl : record_decl->decls()) {
-        auto *var_decl = llvm::dyn_cast<clang::VarDecl>(child_decl);
-        if (!var_decl)
-          continue;
-
-        auto name = var_decl->getName();
-        if (name != "__swift_mangled_name")
-          continue;
-
-        const auto *typedef_type =
-            llvm::dyn_cast<clang::TypedefType>(var_decl->getType());
-        if (!typedef_type)
-          break;
-
-        auto *decl = typedef_type->getDecl();
-        if (!decl)
-          break;
-
-        auto swift_name = decl->getName();
-        if (!swift::Demangle::isMangledName(swift_name))
-          break;
-
-        swift_type = type_system_swift.GetTypeFromMangledTypename(
-            ConstString(swift_name));
-        break;
-      }
 
+      auto swift_type = ExtractSwiftTypeFromCxxInteropType(
+          type, type_system_swift, *swift_runtime);
       if (!swift_type) {
         LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
                        "Did not find Swift type.");

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

@@ -346,6 +346,13 @@ class SwiftLanguageRuntimeStub {
     return {};
   }
 
+  CompilerType BindGenericTypeParameters(
+      CompilerType unbound_type,
+      std::function<CompilerType(unsigned, unsigned)> type_finder) {
+    STUB_LOG();
+    return {};
+  }
+
   CompilerType GetConcreteType(ExecutionContextScope *exe_scope,
                                ConstString abstract_type_name) {
     STUB_LOG();
@@ -1818,6 +1825,20 @@ lldb::ValueObjectSP SwiftLanguageRuntime::ExtractSwiftValueObjectFromCxxWrapper(
 
     auto opaque_ptr_valobj = child_valobj->GetChildAtIndex(0, true);
     swift_valobj = opaque_ptr_valobj;
+  } else if (child_type.GetMangledTypeName() == "swift::_impl::OpaqueStorage") {
+    if (child_valobj->GetNumChildren() != 1)
+      return swift_valobj;
+
+    auto opaque_ptr_valobj = child_valobj->GetChildAtIndex(0, true);
+
+    Status error;
+    opaque_ptr_valobj = opaque_ptr_valobj->Dereference(error);
+    if (error.Success())
+      swift_valobj = opaque_ptr_valobj;
+    else
+      LLDB_LOGF(GetLog(LLDBLog::Types),
+                "Could not dereference opaque storage value object, error: %s",
+                error.AsCString());
   } else {
     CompilerType element_type;
     if (child_type.IsArrayType(&element_type)) {
@@ -2378,6 +2399,12 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress(
           address, value_type);
 }
 
+CompilerType SwiftLanguageRuntime::BindGenericTypeParameters(
+    CompilerType unbound_type,
+    std::function<CompilerType(unsigned, unsigned)> type_resolver) {
+  FORWARD(BindGenericTypeParameters, unbound_type, type_resolver);
+}
+
 void SwiftLanguageRuntime::DumpTyperef(CompilerType type,
                                        TypeSystemSwiftTypeRef *module_holder,
                                        Stream *s) {

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

@@ -219,8 +219,12 @@ class SwiftLanguageRuntime : public LanguageRuntime {
                                 Address &address,
                                 Value::ValueType &value_type) override;
 
+  CompilerType BindGenericTypeParameters(
+      CompilerType unbound_type,
+      std::function<CompilerType(unsigned, unsigned)> finder);
+
   /// Extract the value object which contains the Swift type's "contents".
-  /// Returns null if this is not a C++ wrapping a Swift type. 
+  /// Returns null if this is not a C++ wrapping a Swift type.
   static lldb::ValueObjectSP
   ExtractSwiftValueObjectFromCxxWrapper(ValueObject &valobj);
 

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

@@ -2005,6 +2005,75 @@ ForEachGenericParameter(swift::Demangle::NodePointer node,
   }
 }
 
+CompilerType SwiftLanguageRuntimeImpl::BindGenericTypeParameters(
+    CompilerType unbound_type,
+    std::function<CompilerType(unsigned, unsigned)> type_resolver) {
+  LLDB_SCOPED_TIMER();
+  using namespace swift::Demangle;
+
+  auto ts =
+      unbound_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  Status error;
+  auto *reflection_ctx = GetReflectionContext();
+  if (!reflection_ctx) {
+    LLDB_LOG(GetLog(LLDBLog::Types),
+             "No reflection context available.");
+    return unbound_type;
+  }
+
+  Demangler dem;
+  NodePointer unbound_node =
+      dem.demangleSymbol(unbound_type.GetMangledTypeName().GetStringRef());
+  auto type_ref_or_err =
+      decodeMangledType(reflection_ctx->getBuilder(), unbound_node);
+  if (type_ref_or_err.isError()) {
+    LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
+             "Couldn't get TypeRef of unbound type.");
+    return {};
+  }
+
+  swift::reflection::GenericArgumentMap substitutions;
+  bool failure = false;
+  ForEachGenericParameter(unbound_node, [&](unsigned depth, unsigned index) {
+    if (failure)
+      return;
+    if (substitutions.count({depth, index}))
+      return;
+
+    auto type = type_resolver(depth, index);
+    if (!type) {
+      LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
+               "type_finder function failed to find type.");
+      failure = true;
+      return;
+    }
+
+    NodePointer child_node =
+        dem.demangleSymbol(type.GetMangledTypeName().GetStringRef());
+    auto type_ref_or_err =
+        decodeMangledType(reflection_ctx->getBuilder(), child_node);
+    if (type_ref_or_err.isError()) {
+      LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
+               "Couldn't get TypeRef when binding generic type parameters.");
+      failure = true;
+      return;
+    }
+
+    substitutions.insert({{depth, index}, type_ref_or_err.getType()});
+  });
+
+  if (failure)
+    return {};
+
+  const swift::reflection::TypeRef *type_ref = type_ref_or_err.getType();
+
+  // Apply the substitutions.
+  const swift::reflection::TypeRef *bound_type_ref =
+      type_ref->subst(reflection_ctx->getBuilder(), substitutions);
+  NodePointer node = bound_type_ref->getDemangling(dem);
+  return ts->GetTypeSystemSwiftTypeRef().RemangleAsType(dem, node);
+}
+
 CompilerType
 SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
                                                     TypeSystemSwiftTypeRef &ts,

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

@@ -145,6 +145,10 @@ class SwiftLanguageRuntimeImpl {
       bool &child_is_deref_of_parent, ValueObject *valobj,
       uint64_t &language_flags);
 
+  CompilerType BindGenericTypeParameters(
+      CompilerType unbound_type,
+      std::function<CompilerType(unsigned, unsigned)> type_resolver);
+
   /// Like \p BindGenericTypeParameters but for TypeSystemSwiftTypeRef.
   CompilerType BindGenericTypeParameters(StackFrame &stack_frame,
                                          TypeSystemSwiftTypeRef &ts,

lldb/test/API/lang/swift/cxx_interop/backward/test-format-swift-types-in-cxx/TestSwiftFormatSwiftTypesInCxx.py

@@ -34,3 +34,9 @@ def test_class(self):
         self.expect('p swiftStruct', substrs=['SwiftStruct', 'str = "Hello this is a big string"', 
             'boolean = true'])
 
+        self.expect('v wrapper', substrs=['a.GenericPair<a.SwiftClass, a.SwiftStruct>', 
+                'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+                '[3] = "strings"', 'str = "Hello this is a big string"', 'boolean = true'])
+        self.expect('p wrapper', substrs=['a.GenericPair<a.SwiftClass, a.SwiftStruct>', 
+                'field = 42', 'arr = 4 values', '[0] = "An"', '[1] = "array"', '[2] = "of"', 
+                '[3] = "strings"', 'str = "Hello this is a big string"', 'boolean = true'])

lldb/test/API/lang/swift/cxx_interop/backward/test-format-swift-types-in-cxx/main.cpp

@@ -5,5 +5,6 @@ int main() {
   auto swiftClass = returnSwiftClass();
   auto swiftSublass = returnSwiftSubclassAsClass();
   auto swiftStruct = returnSwiftStruct();
+  auto wrapper = returnPair(swiftClass, swiftStruct);
   return 0; // Set breakpoint here.
 }

lldb/test/API/lang/swift/cxx_interop/backward/test-format-swift-types-in-cxx/swift-types.swift

@@ -13,6 +13,17 @@ public struct SwiftStruct {
   var boolean = true
 }
 
+@frozen
+public struct GenericPair<T, T2> {
+    var x: T
+    var y: T2
+
+    init(x: T, y: T2) {
+        self.x = x
+        self.y = y
+    }
+}
+
 public func returnSwiftClass() -> SwiftClass {
   return SwiftClass()
 }
@@ -24,3 +35,7 @@ public func returnSwiftSubclassAsClass() -> SwiftClass {
 public func returnSwiftStruct() -> SwiftStruct {
   return SwiftStruct()
 }
+
+public func returnPair<T, U>(t: T, u: U) -> GenericPair<T, U> {
+  return GenericPair<T, U>(x: t, y: u)
+}