[lldb] Retire the SwiftASTContextReader lock manager.

This mechanism was put into place to deal with SwiftASTContexts being
torn down and replaced. While that may still happen, we no have a much
better solution for the problem of dangling type references:
CompilerType now holds a weak_ptr to the type system so it's safe to
destroy a type system.

Author: adrian-prantl

lldb/include/lldb/Core/SwiftScratchContextReader.h

@@ -24,7 +24,6 @@
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Core/UserSettingsController.h"
-#include "lldb/Core/SwiftScratchContextReader.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 #include "lldb/Interpreter/OptionValueBoolean.h"
@@ -52,7 +51,10 @@ namespace lldb_private {
 class ClangModulesDeclVendor;
 class SwiftPersistentExpressionState;
 class SharedMutex;
-class SwiftASTContextForExpressions;
+class TypeSystemSwiftTypeRefForExpressions;
+typedef std::shared_ptr<TypeSystemSwiftTypeRefForExpressions>
+    TypeSystemSwiftTypeRefForExpressionsSP;
+
 
 OptionEnumValues GetDynamicValueTypes();
 
@@ -1299,7 +1301,7 @@ class Target : public std::enable_shared_from_this<Target>,
     return m_scratch_typesystem_lock;
   }
 
-  std::optional<SwiftScratchContextReader>
+  TypeSystemSwiftTypeRefForExpressionsSP
   GetSwiftScratchContext(Status &error, ExecutionContextScope &exe_scope,
                          bool create_on_demand = true,
                          bool for_playground = false);
@@ -1310,9 +1312,6 @@ class Target : public std::enable_shared_from_this<Target>,
   bool IsSwiftCxxInteropEnabled();
 
   bool IsEmbeddedSwift();
-private:
-  void DisplayFallbackSwiftContextErrors(
-      SwiftASTContextForExpressions *swift_ast_ctx);
 #endif // LLDB_ENABLE_SWIFT
 
 public:
@@ -1718,11 +1717,7 @@ class Target : public std::enable_shared_from_this<Target>,
   /// signals you will have.
   llvm::StringMap<DummySignalValues> m_dummy_signals;
 
-  bool m_use_scratch_typesystem_per_module = false;
   bool m_did_display_scratch_fallback_warning = false;
-  typedef std::pair<lldb_private::Module *, char> ModuleLanguage;
-  llvm::DenseMap<ModuleLanguage, lldb::TypeSystemSP>
-      m_scratch_typesystem_for_module;
 
   /// Guards the scratch typesystem from being re-initialized.
   std::shared_mutex m_scratch_typesystem_lock;

lldb/include/lldb/Target/Target.h

@@ -9,7 +9,6 @@
 #ifndef LLDB_VALUEOBJECT_VALUEOBJECT_H
 #define LLDB_VALUEOBJECT_VALUEOBJECT_H
 
-#include "lldb/Core/SwiftScratchContextReader.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
@@ -615,7 +614,7 @@ class ValueObject {
   virtual bool HasSyntheticValue();
 
 #ifdef LLDB_ENABLE_SWIFT
-  std::optional<SwiftScratchContextReader> GetSwiftScratchContext();
+  TypeSystemSwiftTypeRefForExpressionsSP GetSwiftScratchContext();
 #endif // LLDB_ENABLE_SWIFT
 
   virtual bool IsSynthetic() { return false; }

lldb/include/lldb/ValueObject/ValueObject.h

@@ -1064,17 +1064,6 @@ class EntityResultVariable : public Materializer::Entity {
 
     if (m_type.GetMinimumLanguage() == lldb::eLanguageTypeSwift) {
 #ifdef LLDB_ENABLE_SWIFT
-      Status status;
-      std::optional<SwiftScratchContextReader> maybe_type_system =
-          target_sp->GetSwiftScratchContext(status, *exe_scope);
-      if (!maybe_type_system) {
-        err = Status::FromErrorStringWithFormat(
-            "Couldn't dematerialize a result variable: "
-            "couldn't get the corresponding type "
-            "system: %s",
-            status.AsCString());
-        return;
-      }
       persistent_state = target_sp->GetPersistentExpressionStateForLanguage(
           lldb::eLanguageTypeSwift);
 #endif // LLDB_ENABLE_SWIFT

lldb/source/Expression/Materializer.cpp

@@ -743,7 +743,7 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
                        target->GetExecutableModule());
   else
     sc = frame->GetSymbolContext(lldb::eSymbolContextFunction);
-  auto *swift_ast_ctx = m_swift_scratch_ctx->get()->GetSwiftASTContext(sc);
+  auto *swift_ast_ctx = m_swift_scratch_ctx->GetSwiftASTContext(sc);
   m_swift_ast_ctx =
       llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(swift_ast_ctx);
 

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

@@ -189,7 +189,7 @@ class SwiftUserExpression : public LLVMUserExpression {
     void DidDematerialize(lldb::ExpressionVariableSP &variable) override;
   };
 
-  std::optional<SwiftScratchContextReader> m_swift_scratch_ctx;
+  TypeSystemSwiftSP m_swift_scratch_ctx;
   SwiftASTContextForExpressions *m_swift_ast_ctx;
   PersistentVariableDelegate m_persistent_variable_delegate;
   std::unique_ptr<SwiftExpressionParser> m_parser;

lldb/source/Plugins/ExpressionParser/Swift/SwiftUserExpression.h

@@ -330,10 +330,7 @@ SwiftArrayBufferHandler::CreateBufferHandler(ValueObject &static_valobj) {
 
     // Get the type of the array elements.
     CompilerType argument_type;
-    auto scratch_ctx_reader = valobj.GetSwiftScratchContext();
-    if (!scratch_ctx_reader)
-      return nullptr;
-    auto *ts = scratch_ctx_reader->get();
+    auto ts = valobj.GetSwiftScratchContext();
     if (!ts)
       return nullptr;
     auto *swift_runtime = SwiftLanguageRuntime::Get(process_sp);

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

@@ -291,15 +291,12 @@ HashedCollectionConfig::StorageObjectAtAddress(
   // same address.
   Status error;
   ExecutionContextScope *exe_scope = exe_ctx.GetBestExecutionContextScope();
-  std::optional<SwiftScratchContextReader> reader =
-    process_sp->GetTarget().GetSwiftScratchContext(error, *exe_scope);
-  if (!reader)
+  auto scratch_ctx =
+      process_sp->GetTarget().GetSwiftScratchContext(error, *exe_scope);
+  if (!scratch_ctx)
     return nullptr;
   if (error.Fail())
     return nullptr;
-  auto scratch_ctx = reader->get();
-  if (!scratch_ctx)
-    return nullptr;
   CompilerType rawStorage_type =
       scratch_ctx->GetTypeFromMangledTypename(m_nativeStorageRoot_mangled);
   if (!rawStorage_type.IsValid())