[lldb] Implement formatting of Swift types in C++ frames via interop

Swift types imported in C++ are wrapped by compiler generated types.
This patch adds functionality to recognize those types, and present the
underlying Swift types via synthetic child providers.

rdar://100285269

Author: augusto2112

lldb/packages/Python/lldbsuite/test/builders/builder.py

@@ -139,6 +139,12 @@ def getLibCxxArgs(self):
                     "LIBCPP_LIBRARY_DIR={}".format(configuration.libcxx_library_dir)]
         return []
 
+    def getLLDBSwiftLibs(self):
+        if configuration.swift_libs_dir:
+            return ["SWIFT_LIBS_DIR={}".format(
+                configuration.swift_libs_dir)]
+        return []
+
     def _getDebugInfoArgs(self, debug_info):
         if debug_info is None:
             return []
@@ -163,7 +169,8 @@ def getBuildCommand(self, debug_info, architecture=None, compiler=None,
             self.getSwiftTargetFlags(architecture), self.getCCSpec(compiler),
             self.getSwiftCSpec(), self.getExtraMakeArgs(),
             self.getSDKRootSpec(), self.getModuleCacheSpec(),
-            self.getLibCxxArgs(), self.getCmdLine(dictionary)]
+            self.getLibCxxArgs(), self.getLLDBSwiftLibs(), 
+            self.getCmdLine(dictionary)]
         command = list(itertools.chain(*command_parts))
 
         return command

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

@@ -118,6 +118,8 @@
 # The clang module cache directory used by clang.
 clang_module_cache_dir = None
 
+swift_libs_dir = None
+
 # Test results handling globals
 test_result = None
 

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

@@ -428,6 +428,9 @@ def parseOptionsAndInitTestdirs():
         configuration.clang_module_cache_dir = os.path.join(
             configuration.test_build_dir, 'module-cache-clang')
 
+    if args.swift_libs_dir:
+        configuration.swift_libs_dir = args.swift_libs_dir
+
     if args.lldb_libs_dir:
         configuration.lldb_libs_dir = args.lldb_libs_dir
 

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

@@ -164,6 +164,11 @@ def create_parser():
         dest='clang_module_cache_dir',
         metavar='The clang module cache directory used by Clang',
         help='The clang module cache directory used in the Make files by Clang while building tests. Defaults to <test build directory>/module-cache-clang.')
+    group.add_argument(
+        '--swift-libs-dir',
+        dest='swift_libs_dir',
+        metavar='The lib directory inside the Swift build directory',
+        help='The lib directory inside the Swift build directory.')
     group.add_argument(
         '--lldb-libs-dir',
         dest='lldb_libs_dir',

lldb/packages/Python/lldbsuite/test/make/Makefile.rules

@@ -280,6 +280,12 @@ ifndef NO_TEST_COMMON_H
   CFLAGS += -include $(THIS_FILE_DIR)/test_common.h
 endif
 
+# If C++ interop is enabled, the generated header file will try to include 
+# SWIFT_LIBS_DIR/swiftToCxx/_SwiftCxxInteroperability.h
+ifneq "$(SWIFT_CXX_INTEROP)" ""
+  CFLAGS += -I$(SWIFT_LIBS_DIR)
+endif
+
 CFLAGS += $(NO_LIMIT_DEBUG_INFO_FLAGS) $(ARCH_CFLAGS)
 SWIFTFLAGS += $(SWIFTFLAGS_EXTRAS)
 SWIFTFLAGS += $(FRAMEWORK_INCLUDES)
@@ -563,6 +569,11 @@ ifneq "$(strip $(DYLIB_SWIFT_SOURCES))" ""
 	USESWIFTDRIVER = 1
 endif
 
+ifneq "$(strip $(SWIFT_SOURCES_FOR_CXX_HEADER))" ""
+	SWIFT_CXX_HEADER =$(strip $(SWIFT_SOURCES:.swift=.o))
+	USESWIFTDRIVER = 1
+endif
+
 ifeq "$(USESWIFTDRIVER)" "1"
 	LDFLAGS +=-L"$(SWIFTLIBS)"
 	ifeq "$(OS)" "Darwin"
@@ -706,6 +717,14 @@ $(SWIFT_OBJC_HEADER): $(SWIFT_SOURCES) $(DYLIB_SWIFT_SOURCES)
 	  -emit-objc-header-path $(SWIFT_OBJC_HEADER)
 endif
 
+ifneq "$(SWIFT_CXX_HEADER)" ""
+$(SWIFT_CXX_HEADER): $(SWIFT_SOURCES) $(SWIFT_BRIDGING_PCH) 
+	@echo "### Building C++ header from Swift" $<
+	$(SWIFT_FE) -typecheck $(VPATHSOURCES) \
+	  $(SWIFT_FEFLAGS) $(SWIFT_HFLAGS) -module-name $(MODULENAME) \
+	  -clang-header-expose-decls=all-public -emit-clang-header-path  $(SWIFT_CXX_HEADER)
+endif
+
 else # USESWIFTDRIVER = 0
 #----------------------------------------------------------------------
 
@@ -850,7 +869,7 @@ endif
 %.o: %.c %.d
 	$(CC) $(CFLAGS) -MT $@ -MD -MP -MF $*.d -c -o $@ $<
 
-%.o: %.cpp %.d $(PCH_OUTPUT)
+%.o: %.cpp %.d $(PCH_OUTPUT) $(SWIFT_CXX_HEADER)
 	$(CXX) $(PCHFLAGS) $(CXXFLAGS) -MT $@ -MD -MP -MF $*.d -c -o $@ $<
 
 %.o: %.m %.d

lldb/source/DataFormatters/FormatManager.cpp

@@ -573,11 +573,15 @@ FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
   case lldb::eLanguageTypeC89:
   case lldb::eLanguageTypeC99:
   case lldb::eLanguageTypeC11:
+  // BEGIN SWIFT
+    return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
   case lldb::eLanguageTypeC_plus_plus:
   case lldb::eLanguageTypeC_plus_plus_03:
   case lldb::eLanguageTypeC_plus_plus_11:
   case lldb::eLanguageTypeC_plus_plus_14:
-    return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
+    // Swift can format C++ types due to Swift/C++ iterop.
+    return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC, lldb::eLanguageTypeSwift};
+  // END SWIFT
   default:
     return {lang_type};
   }

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

@@ -27,6 +27,8 @@
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/LLDBLog.h"
 
 #include "LogChannelSwift.h"
 #include "ObjCRuntimeSyntheticProvider.h"
@@ -856,6 +858,134 @@ SwiftLanguage::GetHardcodedSynthetics() {
           }
           return nullptr;
         });
+    g_formatters.push_back([](lldb_private::ValueObject &valobj,
+                              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());
+      auto *swift_runtime = SwiftLanguageRuntime::Get(process_sp);
+      if (!swift_runtime) {
+        LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
+                       "Could not get the swift runtime.");
+        return nullptr;
+      }
+
+      auto scratch_ctx = valobj.GetSwiftScratchContext();
+      if (!scratch_ctx) {
+        LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
+                       "Could not get the swift scratch context.");
+        return nullptr;
+      }
+      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;
+      }
+
+      if (!swift_type) {
+        LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
+                       "Did not find Swift type.");
+        return nullptr;
+      }
+
+      auto swift_valobj =
+          SwiftLanguageRuntime::ExtractSwiftValueObjectFromCxxWrapper(valobj);
+      if (!swift_valobj) {
+        StreamString clang_desc;
+        type.DumpTypeDescription(&clang_desc);
+
+        StreamString swift_desc;
+        type.DumpTypeDescription(&swift_desc);
+
+        LLDB_LOGF(log,
+                  "[Matching CxxBridgedSyntheticChildProvider] - "
+                  "Was not able to extract Swift value object. Clang type: %s. "
+                  "Swift type: %s",
+                  clang_desc.GetData(), swift_desc.GetData());
+        return nullptr;
+      }
+      // Cast it to a Swift type since thhe swift runtime expects a Swift value
+      // object.
+      auto casted_to_swift = swift_valobj->Cast(swift_type);
+      if (!casted_to_swift) {
+        LLDB_LOGF(log, "[Matching CxxBridgedSyntheticChildProvider] - "
+                       "Could not cast value object to swift type.");
+        return nullptr;
+      }
+
+      TypeAndOrName type_or_name;
+      Address address;
+      Value::ValueType value_type;
+      // Try to find the dynamic type of the Swift type.
+      // TODO: find a way to get the dyamic value type from the
+      // command.
+      if (swift_runtime->GetDynamicTypeAndAddress(
+              *casted_to_swift.get(),
+              lldb::DynamicValueType::eDynamicCanRunTarget, type_or_name,
+              address, value_type)) {
+        if (type_or_name.HasCompilerType()) {
+          swift_type = type_or_name.GetCompilerType();
+          // Cast it to the more specific type.
+          casted_to_swift = casted_to_swift->Cast(swift_type);
+        }
+      }
+
+      return swift_runtime->GetCxxBridgedSyntheticChildProvider(
+          casted_to_swift);
+    });
   });
 
   return g_formatters;