Invert the ownership between SwiftASTContext and TypeSystemSwiftTypeRef (NFC)

This patch introduces a new subclass SwiftASTContextForModules, which
is now owned by TypeSystemSwiftTypeRef and initialized lazily. The
TypeSystemSwiftTypeRef that corresponds to the scratch context is
still owned by SwiftASTContextForExpressions.

rdar://81717792
(cherry picked from commit 744ae39)

Author: adrian-prantl

lldb/source/Core/Module.cpp

@@ -1569,9 +1569,9 @@ bool Module::SetArchitecture(const ArchSpec &new_arch) {
       return true;
     }
 #ifdef LLDB_ENABLE_SWIFT
-    if (auto *swift_ast =
-            llvm::dyn_cast_or_null<SwiftASTContext>(&*type_system_or_err))
-      swift_ast->SetTriple(new_arch.GetTriple());
+    if (auto *ts =
+            llvm::dyn_cast_or_null<TypeSystemSwift>(&*type_system_or_err))
+      ts->SetTriple(new_arch.GetTriple());
 #endif // LLDB_ENABLE_SWIFT
     return true;
   }
@@ -1696,8 +1696,8 @@ void Module::ClearModuleDependentCaches() {
   }
 
 #ifdef LLDB_ENABLE_SWIFT
-  if (auto *swift_ast = llvm::dyn_cast_or_null<SwiftASTContext>(&*type_system_or_err))
-    swift_ast->ClearModuleDependentCaches();
+  if (auto *ts = llvm::dyn_cast_or_null<TypeSystemSwift>(&*type_system_or_err))
+    ts->ClearModuleDependentCaches();
 #endif // LLDB_ENABLE_SWIFT
 }
 

lldb/source/Plugins/InstrumentationRuntime/MainThreadChecker/InstrumentationRuntimeMainThreadChecker.cpp

@@ -101,7 +101,10 @@ static std::string TranslateObjCNameToSwiftName(std::string className,
     return "";
   }
 
-  auto *ctx = llvm::dyn_cast_or_null<SwiftASTContext>(&*type_system_or_err);
+  auto *ts = llvm::dyn_cast_or_null<TypeSystemSwift>(&*type_system_or_err);
+  if (!ts)
+    return "";
+  auto *ctx = ts->GetSwiftASTContext();
   if (!ctx)
     return "";
   swift::ClangImporter *imp = ctx->GetClangImporter();

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

@@ -1872,7 +1872,7 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress_Protocol(
   }
 
   const swift::reflection::TypeRef *protocol_typeref =
-      GetTypeRef(protocol_type, tss->GetSwiftASTContext());
+      GetTypeRef(protocol_type, &tss->GetTypeSystemSwiftTypeRef());
   if (!protocol_typeref) {
     if (log)
       log->Printf("Could not get protocol typeref");
@@ -2841,7 +2841,7 @@ lldb::addr_t SwiftLanguageRuntimeImpl::FixupAddress(lldb::addr_t addr,
 
 const swift::reflection::TypeRef *
 SwiftLanguageRuntimeImpl::GetTypeRef(CompilerType type,
-                                     SwiftASTContext *module_holder) {
+                                     TypeSystemSwiftTypeRef *module_holder) {
   // Demangle the mangled name.
   swift::Demangle::Demangler dem;
   ConstString mangled_name = type.GetMangledTypeName();
@@ -2850,8 +2850,10 @@ SwiftLanguageRuntimeImpl::GetTypeRef(CompilerType type,
     return nullptr;
   swift::Demangle::NodePointer node =
       TypeSystemSwiftTypeRef::GetCanonicalDemangleTree(
-          module_holder ? module_holder : ts->GetSwiftASTContext(), dem,
-          mangled_name.GetStringRef());
+          module_holder ? module_holder : &ts->GetTypeSystemSwiftTypeRef(),
+          module_holder ? module_holder->GetSwiftASTContext()
+                        : ts->GetSwiftASTContext(),
+          dem, mangled_name.GetStringRef());
   if (!node)
     return nullptr;
 
@@ -2895,7 +2897,7 @@ SwiftLanguageRuntimeImpl::GetSwiftRuntimeTypeInfo(
   // context, but we need to resolve (any DWARF links in) the typeref
   // in the original module.
   const swift::reflection::TypeRef *type_ref =
-      GetTypeRef(type, ts->GetSwiftASTContext());
+      GetTypeRef(type, &ts->GetTypeSystemSwiftTypeRef());
   if (!type_ref)
     return nullptr;
 

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

@@ -182,8 +182,8 @@ class SwiftLanguageRuntimeImpl {
       swift::External<swift::RuntimeTarget<sizeof(uintptr_t)>>>;
 
   /// Use the reflection context to build a TypeRef object.
-  const swift::reflection::TypeRef *GetTypeRef(CompilerType type,
-                                               SwiftASTContext *module_holder);
+  const swift::reflection::TypeRef *
+  GetTypeRef(CompilerType type, TypeSystemSwiftTypeRef *module_holder);
 
   /// Returned by \ref ForEachSuperClassType. Not every user of \p
   /// ForEachSuperClassType needs all of these. By returning this

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

@@ -187,6 +187,7 @@ using namespace lldb;
 using namespace lldb_private;
 
 char SwiftASTContext::ID;
+char SwiftASTContextForModule::ID;
 char SwiftASTContextForExpressions::ID;
 
 CompilerType lldb_private::ToCompilerType(swift::Type qual_type) {
@@ -200,7 +201,7 @@ TypePayloadSwift::TypePayloadSwift(bool is_fixed_value_buffer) {
 }
 
 CompilerType SwiftASTContext::GetCompilerType(ConstString mangled_name) {
-  return m_typeref_typesystem.GetTypeFromMangledTypename(mangled_name);
+  return GetTypeSystemSwiftTypeRef().GetTypeFromMangledTypename(mangled_name);
 }
 
 CompilerType SwiftASTContext::GetCompilerType(swift::TypeBase *swift_type) {
@@ -216,7 +217,9 @@ swift::Type TypeSystemSwiftTypeRef::GetSwiftType(CompilerType compiler_type) {
   // FIXME: Suboptimal performance, because the ConstString is looked up again.
   ConstString mangled_name(
       reinterpret_cast<const char *>(compiler_type.GetOpaqueQualType()));
-  return ts->m_swift_ast_context->ReconstructType(mangled_name);
+  if (auto *swift_ast_context = ts->GetSwiftASTContext())
+    return swift_ast_context->ReconstructType(mangled_name);
+  return {};
 }
 
 swift::Type SwiftASTContext::GetSwiftType(CompilerType compiler_type) {
@@ -899,14 +902,14 @@ static std::string GetClangModulesCacheProperty() {
 }
 
 #ifndef NDEBUG
-SwiftASTContext::SwiftASTContext() : m_typeref_typesystem(this) {
+SwiftASTContext::SwiftASTContext() {
   llvm::dbgs() << "Initialized mock SwiftASTContext\n";
 }
 #endif
 
 SwiftASTContext::SwiftASTContext(std::string description, llvm::Triple triple,
                                  Target *target)
-    : TypeSystemSwift(), m_typeref_typesystem(this),
+    : TypeSystemSwift(),
       m_compiler_invocation_ap(new swift::CompilerInvocation()) {
   m_description = description;
 
@@ -1613,10 +1616,11 @@ static bool IsDWARFImported(swift::ModuleDecl &module) {
                      });
 }
 
-lldb::TypeSystemSP SwiftASTContext::CreateInstance(lldb::LanguageType language,
-                                                   Module &module,
-                                                   Target *target,
-                                                   bool fallback) {
+lldb::TypeSystemSP
+SwiftASTContext::CreateInstance(lldb::LanguageType language, Module &module,
+                                TypeSystemSwiftTypeRef *typeref_typesystem,
+                                Target *target, bool fallback) {
+  assert(((bool)fallback && (bool)target) != (bool)typeref_typesystem);
   if (!SwiftASTContextSupportsLanguage(language))
     return lldb::TypeSystemSP();
 
@@ -1626,6 +1630,8 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(lldb::LanguageType language,
     ss << "SwiftASTContext";
     if (fallback)
       ss << "ForExpressions";
+    else
+      ss << "ForModule";
     ss << '(' << '"';
     module.GetDescription(ss, eDescriptionLevelBrief);
     ss << '"' << ')';
@@ -1688,9 +1694,10 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(lldb::LanguageType language,
   // If there is a target this may be a fallback scratch context.
   assert((!fallback || target) && "fallback context must specify a target");
   std::shared_ptr<SwiftASTContext> swift_ast_sp(
-      fallback ? (new SwiftASTContextForExpressions(m_description, *target))
-               : (new SwiftASTContext(
-                     m_description,
+      fallback ? static_cast<SwiftASTContext *>(
+                     new SwiftASTContextForExpressions(m_description, *target))
+               : static_cast<SwiftASTContext *>(new SwiftASTContextForModule(
+                     *typeref_typesystem, m_description,
                      target ? target->GetArchitecture().GetTriple() : triple,
                      target)));
   bool suppress_config_log = false;
@@ -1922,6 +1929,19 @@ static lldb::ModuleSP GetUnitTestModule(lldb_private::ModuleList &modules) {
   return ModuleSP();
 }
 
+static SwiftASTContext *GetModuleSwiftASTContext(Module &module) {
+  auto type_system_or_err =
+      module.GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
+  if (!type_system_or_err) {
+    llvm::consumeError(type_system_or_err.takeError());
+    return {};
+  }
+  auto *ts = static_cast<TypeSystemSwift *>(&*type_system_or_err);
+  if (!ts)
+    return {};
+  return ts->GetSwiftASTContext();
+}
+
 /// Scan a newly added lldb::Module for Swift modules and report any errors in
 /// its module SwiftASTContext to Target.
 static void
@@ -2002,16 +2022,7 @@ ProcessModule(ModuleSP module_sp, std::string m_description,
   if (!HasSwiftModules(*module_sp))
     return;
 
-  auto type_system_or_err =
-      module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
-  if (!type_system_or_err) {
-    llvm::consumeError(type_system_or_err.takeError());
-    return;
-  }
-
-  SwiftASTContext *ast_context =
-      llvm::dyn_cast_or_null<SwiftASTContext>(&*type_system_or_err);
-
+  SwiftASTContext *ast_context = GetModuleSwiftASTContext(*module_sp);
   if (!ast_context || ast_context->HasFatalErrors() ||
       !ast_context->GetClangImporter()) {
     // Make sure we warn about this module load failure, the one
@@ -2163,11 +2174,7 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(lldb::LanguageType language,
       for (size_t mi = 0; mi != num_images; ++mi) {
         auto module_sp = target.GetImages().GetModuleAtIndex(mi);
         pool.async([=] {
-          auto val_or_err =
-              module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
-          if (!val_or_err) {
-            llvm::consumeError(val_or_err.takeError());
-          }
+          GetModuleSwiftASTContext(*module_sp);
         });
       }
       pool.wait();
@@ -2181,15 +2188,7 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(lldb::LanguageType language,
       if (!HasSwiftModules(*module_sp))
         continue;
 
-      auto type_system_or_err =
-          module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
-      if (!type_system_or_err) {
-        llvm::consumeError(type_system_or_err.takeError());
-        continue;
-      }
-
-      auto *module_swift_ast =
-          llvm::dyn_cast_or_null<SwiftASTContext>(&*type_system_or_err);
+      SwiftASTContext *module_swift_ast = GetModuleSwiftASTContext(*module_sp);
       if (!module_swift_ast || module_swift_ast->HasFatalErrors() ||
           !module_swift_ast->GetClangImporter())
         continue;
@@ -2222,14 +2221,7 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(lldb::LanguageType language,
     auto get_executable_triple = [&]() -> llvm::Triple {
       if (!exe_module_sp)
         return {};
-      auto type_system_or_err =
-          exe_module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
-      if (!type_system_or_err) {
-        llvm::consumeError(type_system_or_err.takeError());
-        return {};
-      }
-      auto *exe_ast_ctx =
-          llvm::dyn_cast_or_null<SwiftASTContext>(&type_system_or_err.get());
+      auto *exe_ast_ctx = GetModuleSwiftASTContext(*exe_module_sp);
       if (!exe_ast_ctx)
         return {};
       return exe_ast_ctx->GetLanguageOptions().Target;
@@ -3271,7 +3263,7 @@ class SwiftDWARFImporterDelegate : public swift::DWARFImporterDelegate {
                        TypeSystemClang::GetSupportedLanguagesForTypes(),
                        searched_symbol_files, clang_types);
     };
-    if (Module *module = m_swift_ast_ctx.GetModule())
+    if (Module *module = m_swift_ast_ctx.GetTypeSystemSwiftTypeRef().GetModule())
       search(*module);
     else if (TargetSP target_sp = m_swift_ast_ctx.GetTarget().lock()) {
       // In a scratch context, check the module's DWARFImporterDelegates first.
@@ -3282,12 +3274,7 @@ class SwiftDWARFImporterDelegate : public swift::DWARFImporterDelegate {
       auto images = target_sp->GetImages();
       for (size_t i = 0; i != images.GetSize(); ++i) {
         auto module_sp = images.GetModuleAtIndex(i);
-        auto ts = module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeSwift);
-        if (!ts) {
-          llvm::consumeError(ts.takeError());
-          continue;
-        }
-        auto *swift_ast_ctx = static_cast<SwiftASTContext *>(&*ts);
+        auto *swift_ast_ctx = GetModuleSwiftASTContext(*module_sp);
         auto *dwarf_imp = static_cast<SwiftDWARFImporterDelegate *>(
             swift_ast_ctx->GetDWARFImporterDelegate());
         if (!dwarf_imp || dwarf_imp == this)
@@ -4346,7 +4333,7 @@ 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.
-  Module *module = GetModule();
+  Module *module = GetTypeSystemSwiftTypeRef().GetModule();
   if (!module)
     return {};
   auto type_system_or_err =
@@ -4811,7 +4798,7 @@ CompilerType SwiftASTContext::ImportType(CompilerType &type, Status &error) {
   if (!mangled_name)
     return {};
   if (llvm::isa<TypeSystemSwiftTypeRef>(ts))
-    return m_typeref_typesystem.GetTypeFromMangledTypename(mangled_name);
+    return GetTypeSystemSwiftTypeRef().GetTypeFromMangledTypename(mangled_name);
   swift::TypeBase *our_type_base =
       m_mangled_name_to_type_map.lookup(mangled_name.GetCString());
   if (our_type_base)
@@ -5100,7 +5087,7 @@ void SwiftASTContext::PrintDiagnostics(DiagnosticManager &diagnostic_manager,
   }
 }
 
-void SwiftASTContext::ModulesDidLoad(ModuleList &module_list) {
+void SwiftASTContextForExpressions::ModulesDidLoad(ModuleList &module_list) {
   ClearModuleDependentCaches();
 
   // Scan the new modules for Swift contents and try to import it if
@@ -5562,7 +5549,7 @@ SwiftASTContext::GetAllocationStrategy(opaque_compiler_type_t type) {
 
 CompilerType
 SwiftASTContext::GetTypeRefType(lldb::opaque_compiler_type_t type) {
-  return m_typeref_typesystem.GetTypeFromMangledTypename(
+  return GetTypeSystemSwiftTypeRef().GetTypeFromMangledTypename(
       GetMangledTypeName(type));
 }
 
@@ -8335,6 +8322,7 @@ SwiftASTContextForExpressions::SwiftASTContextForExpressions(
     std::string description, Target &target)
     : SwiftASTContext(std::move(description),
                       target.GetArchitecture().GetTriple(), &target),
+      m_typeref_typesystem(*this),
       m_persistent_state_up(new SwiftPersistentExpressionState) {}
 
 UserExpression *SwiftASTContextForExpressions::GetUserExpression(