[lldb] Resolve Swift-implemented Objective-C classes using Swift runtime

if the Objective-C runtime fails. If an Objective-C class is lazy, the
Objective-C runtie may not have materialized class metadata for
it. However, if the class is actually implemented in Swift, we can
still resolve it using the Swift runtime. We should probably also add
the same logic to the Objective-C runtime, but I don't want risk
adding an inifinite recursion at this point in the release.

rdar://145253225

Author: adrian-prantl

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

@@ -501,13 +501,30 @@ bool SwiftREPL::PrintOneVariable(Debugger &debugger, StreamFileSP &output_sp,
     options.SetRevealEmptyAggregates(false);
     options.SetHidePointerValue(true);
     options.SetVariableFormatDisplayLanguage(lldb::eLanguageTypeSwift);
-    options.SetDeclPrintingHelper([](ConstString type_name,
-                                     ConstString var_name,
-                                     const DumpValueObjectOptions &options,
-                                     Stream &stream) -> bool {
+    options.SetDeclPrintingHelper([&](ConstString type_name,
+                                      ConstString var_name,
+                                      const DumpValueObjectOptions &options,
+                                      Stream &stream) -> bool {
       if (!type_name || !var_name)
         return false;
 
+      // Try to get the SwiftASTContext representation of the type. It
+      // will hide Objective-C implemention details that are not
+      // publicly declared in the SDK.
+      if (valobj_sp) {
+        auto static_valobj_sp = valobj_sp->GetStaticValue();
+        auto dynamic_valobj_sp =
+            valobj_sp->GetDynamicValue(lldb::eDynamicCanRunTarget);
+        if (static_valobj_sp && dynamic_valobj_sp) {
+          CompilerType static_type = static_valobj_sp->GetCompilerType();
+          CompilerType dynamic_type = dynamic_valobj_sp->GetCompilerType();
+          auto ts =
+              dynamic_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+          if (ts &&
+              ts->IsImportedType(dynamic_type.GetOpaqueQualType(), nullptr))
+            type_name = static_type.GetDisplayTypeName();
+        }
+      }
       std::string type_name_str(type_name ? type_name.GetCString() : "");
       for (auto iter = type_name_str.find(" *"); iter != std::string::npos;
            iter = type_name_str.find(" *")) {

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

@@ -200,6 +200,9 @@ HashedCollectionConfig::RegisterSummaryProviders(
   AddCXXSummary(swift_category_sp, summaryProvider,
                 m_summaryProviderName.AsCString(),
                 m_emptyStorage_demangled, flags, false);
+  AddCXXSummary(swift_category_sp, summaryProvider,
+                m_summaryProviderName.AsCString(),
+                m_nativeStorageRoot_demangled, flags, false);
   AddCXXSummary(swift_category_sp, summaryProvider,
                 m_summaryProviderName.AsCString(),
                 m_deferredBridgedStorage_demangledRegex, flags, true);
@@ -231,6 +234,9 @@ HashedCollectionConfig::RegisterSyntheticChildrenCreators(
   AddCXXSynthetic(swift_category_sp, creator,
                   m_syntheticChildrenName.AsCString(),
                   m_nativeStorage_demangledRegex, flags, true);
+  AddCXXSynthetic(swift_category_sp, creator,
+                  m_syntheticChildrenName.AsCString(),
+                  m_nativeStorageRoot_demangled, flags, false);
   AddCXXSynthetic(swift_category_sp, creator,
                   m_syntheticChildrenName.AsCString(),
                   m_emptyStorage_demangled, flags, false);
@@ -648,18 +654,22 @@ HashedCollectionConfig::CreateHandler(ValueObject &valobj) const {
     return CreateNativeHandler(valobj_sp, storage_sp);
   }
 
-  ValueObjectSP variant_sp =
-    valobj_sp->GetChildMemberWithName(g__variant, true);
-  if (!variant_sp)
-    return nullptr;
+  lldb::addr_t storage_location = LLDB_INVALID_ADDRESS;
+  if (type_name_cs == m_nativeStorageRoot_demangled)
+    storage_location = valobj_sp->GetPointerValue();
+  else {
+    ValueObjectSP variant_sp =
+        valobj_sp->GetChildMemberWithName(g__variant, true);
+    if (!variant_sp)
+      return nullptr;
 
-  ValueObjectSP bobject_sp =
-    variant_sp->GetChildAtNamePath({g_object, g_rawValue});
-  if (!bobject_sp)
-    return nullptr;
+    ValueObjectSP bobject_sp =
+        variant_sp->GetChildAtNamePath({g_object, g_rawValue});
+    if (!bobject_sp)
+      return nullptr;
 
-  lldb::addr_t storage_location =
-    bobject_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+    storage_location = bobject_sp->GetValueAsUnsigned(LLDB_INVALID_ADDRESS);
+  }
   if (storage_location == LLDB_INVALID_ADDRESS)
     return nullptr;
 

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

@@ -2022,21 +2022,6 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Pack(
   return true;
 }
 
-static bool IsPrivateNSClass(NodePointer node) {
-  if (!node || node->getKind() != Node::Kind::Type ||
-      node->getNumChildren() == 0)
-    return false;
-  NodePointer classNode = node->getFirstChild();
-  if (!classNode || classNode->getKind() != Node::Kind::Class ||
-      classNode->getNumChildren() < 2)
-    return false;
-  for (NodePointer child : *classNode)
-    if (child->getKind() == Node::Kind::Identifier && child->hasText())
-      return child->getText().starts_with("__NS") ||
-             child->getText().starts_with("NSTaggedPointer");
-  return false;
-}
-
 CompilerType SwiftLanguageRuntime::GetDynamicTypeAndAddress_EmbeddedClass(
     uint64_t instance_ptr, CompilerType class_type) {
   ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
@@ -2091,44 +2076,41 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Class(
     return false;
 
   auto tss = class_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!tss) {
+    // This could be an Objective-C type implemented in Swift. Get the
+    // Swift typesystem.
+    if (auto module_sp = in_value.GetModule()) {
+      auto type_system_or_err =
+          module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
+      if (!type_system_or_err) {
+        llvm::consumeError(type_system_or_err.takeError());
+        return false;
+      }
+      auto ts_sp = *type_system_or_err;
+      tss =
+          llvm::cast<TypeSystemSwift>(ts_sp.get())->GetTypeSystemSwiftTypeRef();
+    } else if (auto target_sp = in_value.GetTargetSP()) {
+      auto type_system_or_err =
+          target_sp->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeSwift);
+      if (!type_system_or_err) {
+        llvm::consumeError(type_system_or_err.takeError());
+        return false;
+      }
+      auto ts_sp = *type_system_or_err;
+      tss =
+          llvm::cast<TypeSystemSwift>(ts_sp.get())->GetTypeSystemSwiftTypeRef();
+    }
+  }
   if (!tss)
     return false;
+
   address.SetRawAddress(instance_ptr);
   auto ts = tss->GetTypeSystemSwiftTypeRef();
   if (!ts)
     return false;
-  // Ask the Objective-C runtime about Objective-C types.
-  if (tss->IsImportedType(class_type.GetOpaqueQualType(), nullptr))
-    if (auto *objc_runtime =
-            SwiftLanguageRuntime::GetObjCRuntime(GetProcess())) {
-      Value::ValueType value_type;
-      if (objc_runtime->GetDynamicTypeAndAddress(in_value, use_dynamic,
-                                                 class_type_or_name, address,
-                                                 value_type, local_buffer)) {
-        bool found = false;
-        // Return the most specific class which we can get the typeref.
-        ForEachSuperClassType(in_value, [&](SuperClassType sc) -> bool {
-          if (auto *tr = sc.get_typeref()) {
-            swift::Demangle::Demangler dem;
-            swift::Demangle::NodePointer node = tr->getDemangling(dem);
-            // Skip private Foundation types since it's unlikely that would be
-            // useful to users.
-            if (IsPrivateNSClass(node))
-              return false;
-            class_type_or_name.SetCompilerType(ts->RemangleAsType(
-                dem, node, swift::Mangle::ManglingFlavor::Default));
-            found = true;
-            return true;
-          }
-          return false;
-        });
-        return found;
-      }
-      return false;
-    }
-  Log *log(GetLog(LLDBLog::Types));
-  // Scope reflection_ctx to minimize its lock scope.
-  {
+
+  auto resolve_swift = [&]() {
+    // Scope reflection_ctx to minimize its lock scope.
     ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
     if (!reflection_ctx)
       return false;
@@ -2172,10 +2154,17 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Class(
         return false;
       }
     }
-
-    LLDB_LOG(log, "dynamic type of instance_ptr {0:x} is {1}", instance_ptr,
-             class_type.GetMangledTypeName());
     class_type_or_name.SetCompilerType(dynamic_type);
+    LLDB_LOG(GetLog(LLDBLog::Types),
+             "dynamic type of instance_ptr {0:x} is {1}", instance_ptr,
+             class_type.GetMangledTypeName());
+    return true;
+  };
+
+  if (!resolve_swift()) {
+    // When returning false here, the next compatible runtime (=
+    // Objective-C) will get ask to resolve this type.
+    return false;
   }
 
 #ifndef NDEBUG
@@ -2833,12 +2822,12 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_IndirectEnumCase(
 
     return GetDynamicTypeAndAddress(*valobj_sp, use_dynamic, class_type_or_name,
                                     address, value_type, local_buffer);
-  } else {
-    // This is most likely a statically known type.
-    address.SetLoadAddress(box_value, &GetProcess().GetTarget());
-    value_type = Value::GetValueTypeFromAddressType(eAddressTypeLoad);
-    return true;
   }
+
+  // This is most likely a statically known type.
+  address.SetLoadAddress(box_value, &GetProcess().GetTarget());
+  value_type = Value::GetValueTypeFromAddressType(eAddressTypeLoad);
+  return true;
 }
 
 void SwiftLanguageRuntime::DumpTyperef(CompilerType type,
@@ -3156,22 +3145,27 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress(
     return false;
 
   LLDB_SCOPED_TIMER();
+  CompilerType val_type(in_value.GetCompilerType());
+  Value::ValueType static_value_type = Value::ValueType::Invalid;
 
   // Try to import a Clang type into Swift.
-  if (in_value.GetObjectRuntimeLanguage() == eLanguageTypeObjC)
-    return GetDynamicTypeAndAddress_ClangType(in_value, use_dynamic,
-                                              class_type_or_name, address,
-                                              value_type, local_buffer);
+  if (in_value.GetObjectRuntimeLanguage() == eLanguageTypeObjC) {
+    if (GetDynamicTypeAndAddress_ClangType(in_value, use_dynamic,
+                                           class_type_or_name, address,
+                                           value_type, local_buffer))
+      return true;
+    return GetDynamicTypeAndAddress_Class(in_value, val_type, use_dynamic,
+                                          class_type_or_name, address,
+                                          static_value_type, local_buffer);
+  }
 
   if (!CouldHaveDynamicValue(in_value))
     return false;
 
-  CompilerType val_type(in_value.GetCompilerType());
   Flags type_info(val_type.GetTypeInfo());
   if (!type_info.AnySet(eTypeIsSwift))
     return false;
 
-  Value::ValueType static_value_type = Value::ValueType::Invalid;
   bool success = false;
   bool is_indirect_enum_case = IsIndirectEnumCase(in_value);
   // Type kinds with instance metadata don't need generic type resolution.

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

@@ -996,7 +996,7 @@ SwiftASTContext::SwiftASTContext()
 }
 #endif
 
-SwiftASTContext::SwiftASTContext(std::string description,
+SwiftASTContext::SwiftASTContext(std::string description, ModuleSP module_sp,
                                  TypeSystemSwiftTypeRefSP typeref_typesystem)
     : TypeSystemSwift(), m_typeref_typesystem(typeref_typesystem),
       m_compiler_invocation_ap(new swift::CompilerInvocation()),
@@ -1006,6 +1006,7 @@ SwiftASTContext::SwiftASTContext(std::string description,
       "Swift AST context instantiation is disabled!");
 
   m_description = description;
+  m_module = module_sp.get();
 
   // Set the clang modules cache path.
   m_compiler_invocation_ap->setClangModuleCachePath(
@@ -2431,7 +2432,8 @@ SwiftASTContext::CreateInstance(lldb::LanguageType language, Module &module,
   // If there is a target this may be a fallback scratch context.
   std::shared_ptr<SwiftASTContext> swift_ast_sp(
       static_cast<SwiftASTContext *>(new SwiftASTContextForModule(
-          m_description, typeref_typesystem.GetTypeSystemSwiftTypeRef())));
+          m_description, module.shared_from_this(),
+          typeref_typesystem.GetTypeSystemSwiftTypeRef())));
   bool suppress_config_log = false;
   auto defer_log =
       llvm::make_scope_exit([swift_ast_sp, &suppress_config_log] {
@@ -2444,7 +2446,6 @@ SwiftASTContext::CreateInstance(lldb::LanguageType language, Module &module,
 
   // This is a module AST context, mark it as such.
   swift_ast_sp->m_is_scratch_context = false;
-  swift_ast_sp->m_module = &module;
   swift_ast_sp->GetLanguageOptions().EnableAccessControl = false;
   swift_ast_sp->GetLanguageOptions().EnableCXXInterop =
       module.IsSwiftCxxInteropEnabled();
@@ -2781,7 +2782,8 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
       return {};
     }
     swift_ast_sp.reset(new SwiftASTContextForExpressions(
-        m_description, typeref_typesystem.GetTypeSystemSwiftTypeRef()));
+        m_description, module_sp,
+        typeref_typesystem.GetTypeSystemSwiftTypeRef()));
     // This is a scratch AST context, mark it as such.
     swift_ast_sp->m_is_scratch_context = true;
     auto &lang_opts = swift_ast_sp->GetLanguageOptions();
@@ -2796,10 +2798,10 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
     }
     swift_ast_sp.reset(
         static_cast<SwiftASTContext *>(new SwiftASTContextForModule(
-            m_description, typeref_typesystem.GetTypeSystemSwiftTypeRef())));
+            m_description, module_sp,
+            typeref_typesystem.GetTypeSystemSwiftTypeRef())));
     // This is a module AST context, mark it as such.
     swift_ast_sp->m_is_scratch_context = false;
-    swift_ast_sp->m_module = module_sp.get();
     auto &lang_opts = swift_ast_sp->GetLanguageOptions();
     lang_opts.EnableAccessControl = false;
     lang_opts.EnableCXXInterop = ShouldEnableCXXInterop(cu);
@@ -4695,14 +4697,10 @@ CompilerType SwiftASTContext::GetAsClangType(ConstString mangled_name) {
   // that look like they might be come from Objective-C (or C) as
   // Clang types. LLDB's Objective-C part is very robust against
   // malformed object pointers, so this isn't very risky.
-  auto ts = GetTypeSystemSwiftTypeRef();
-  if (!ts)
-    return {};
-  Module *module = ts->GetModule();
-  if (!module)
+  if (!m_module)
     return {};
   auto type_system_or_err =
-      module->GetTypeSystemForLanguage(eLanguageTypeObjC);
+      m_module->GetTypeSystemForLanguage(eLanguageTypeObjC);
   if (!type_system_or_err) {
     llvm::consumeError(type_system_or_err.takeError());
     return {};
@@ -4714,11 +4712,16 @@ CompilerType SwiftASTContext::GetAsClangType(ConstString mangled_name) {
     return {};
   DWARFASTParserClang *clang_ast_parser =
       static_cast<DWARFASTParserClang *>(clang_ctx->GetDWARFParser());
+
+  SymbolContext sc;
+  m_module->CalculateSymbolContext(&sc);
   CompilerType clang_type;
   CompilerType imported_type = GetCompilerType(mangled_name);
-  if (auto ts =
-          imported_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>())
-    ts->IsImportedType(imported_type.GetOpaqueQualType(), &clang_type);
+  if (auto ts = imported_type.GetTypeSystem()
+                    .dyn_cast_or_null<TypeSystemSwiftTypeRef>())
+    if (ts->IsImportedType(imported_type.GetOpaqueQualType(), nullptr))
+      if (TypeSP result = ts->LookupClangType(mangled_name, sc))
+        clang_type = result->GetForwardCompilerType();
 
   // Import the Clang type into the Clang context.
   if (!clang_type)
@@ -8930,8 +8933,9 @@ SwiftASTContext::GetASTVectorForModule(const Module *module) {
 }
 
 SwiftASTContextForExpressions::SwiftASTContextForExpressions(
-    std::string description, TypeSystemSwiftTypeRefSP typeref_typesystem)
-    : SwiftASTContext(std::move(description), typeref_typesystem) {
+    std::string description, ModuleSP module_sp,
+    TypeSystemSwiftTypeRefSP typeref_typesystem)
+    : SwiftASTContext(std::move(description), module_sp, typeref_typesystem) {
   assert(llvm::isa<TypeSystemSwiftTypeRefForExpressions>(
       m_typeref_typesystem.lock().get()));
 }