[lldb] Retire the Swift-specific scratch context accessors

These used to be necessary because there used to be context-specific
scratch contexts, however, now there is only one global
TypeSystemSwiftTypeRefForExpressions, and it manages multiple
SwiftASTContexts. Therefore it is no longer necessary to have
Swift-specific hooks in Target and ValueObject.

Author: adrian-prantl

lldb/include/lldb/Symbol/TypeSystem.h

@@ -612,14 +612,6 @@ class TypeSystemMap {
   GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
                            bool can_create);
 
-  // BEGIN SWIFT
-  llvm::Expected<lldb::TypeSystemSP>
-  GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
-                           bool can_create, const char *compiler_options);
-
-  void RemoveTypeSystemsForLanguage(lldb::LanguageType language);
-  // END SWIFT
-
   /// Check all type systems in the map to see if any have forcefully completed
   /// types;
   bool GetHasForcefullyCompletedTypes() const;

lldb/include/lldb/Target/Target.h

@@ -1248,20 +1248,14 @@ class Target : public std::enable_shared_from_this<Target>,
 
   llvm::Expected<lldb::TypeSystemSP>
   GetScratchTypeSystemForLanguage(lldb::LanguageType language,
-                                  bool create_on_demand = true,
-                                  const char *compiler_options = nullptr);
+                                  bool create_on_demand = true);
 
   std::vector<lldb::TypeSystemSP>
   GetScratchTypeSystems(bool create_on_demand = true);
 
   PersistentExpressionState *
   GetPersistentExpressionStateForLanguage(lldb::LanguageType language);
 
-#ifdef LLDB_ENABLE_SWIFT
-  SwiftPersistentExpressionState *
-  GetSwiftPersistentExpressionState(ExecutionContextScope &exe_scope);
-#endif // LLDB_ENABLE_SWIFT
-
   const TypeSystemMap &GetTypeSystemMap();
 
   // Creates a UserExpression for the given language, the rest of the
@@ -1294,18 +1288,7 @@ class Target : public std::enable_shared_from_this<Target>,
   CreateUtilityFunction(std::string expression, std::string name,
                         lldb::LanguageType language, ExecutionContext &exe_ctx);
 
-
 #ifdef LLDB_ENABLE_SWIFT
-  /// Get the lock guarding the scratch typesystem from being re-initialized.
-  std::shared_mutex &GetSwiftScratchContextLock() {
-    return m_scratch_typesystem_lock;
-  }
-
-  TypeSystemSwiftTypeRefForExpressionsSP
-  GetSwiftScratchContext(Status &error, ExecutionContextScope &exe_scope,
-                         bool create_on_demand = true,
-                         bool for_playground = false);
-
   /// Return whether this is the Swift REPL.
   bool IsSwiftREPL();
 
@@ -1719,9 +1702,6 @@ class Target : public std::enable_shared_from_this<Target>,
 
   bool m_did_display_scratch_fallback_warning = false;
 
-  /// Guards the scratch typesystem from being re-initialized.
-  std::shared_mutex m_scratch_typesystem_lock;
-
   static void ImageSearchPathsChanged(const PathMappingList &path_list,
                                       void *baton);
 

lldb/include/lldb/ValueObject/ValueObject.h

@@ -613,10 +613,6 @@ class ValueObject {
 
   virtual bool HasSyntheticValue();
 
-#ifdef LLDB_ENABLE_SWIFT
-  TypeSystemSwiftTypeRefForExpressionsSP GetSwiftScratchContext();
-#endif // LLDB_ENABLE_SWIFT
-
   virtual bool IsSynthetic() { return false; }
 
   lldb::ValueObjectSP

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

@@ -143,8 +143,9 @@ LLDBNameLookup::LLDBNameLookup(
 
   if (!m_sc.target_sp)
     return;
-  m_persistent_vars =
-      m_sc.target_sp->GetSwiftPersistentExpressionState(exe_scope);
+  m_persistent_vars = llvm::cast<SwiftPersistentExpressionState>(
+      m_sc.target_sp->GetPersistentExpressionStateForLanguage(
+          lldb::eLanguageTypeSwift));
 }
 
 swift::SILValue LLDBNameLookup::emitLValueForVariable(
@@ -711,7 +712,8 @@ static void ResolveSpecialNames(
     return;
 
   auto *persistent_state =
-      sc.target_sp->GetSwiftPersistentExpressionState(exe_scope);
+      sc.target_sp->GetPersistentExpressionStateForLanguage(
+          lldb::eLanguageTypeSwift);
 
   std::set<ConstString> resolved_names;
 
@@ -1836,8 +1838,9 @@ SwiftExpressionParser::Parse(DiagnosticManager &diagnostic_manager,
   // Allow variables to be re-used from previous REPL statements.
   if (m_sc.target_sp && (repl || !playground)) {
     Status error;
-    auto *persistent_state =
-        m_sc.target_sp->GetSwiftPersistentExpressionState(*m_exe_scope);
+    auto *persistent_state = llvm::cast<SwiftPersistentExpressionState>(
+        m_sc.target_sp->GetPersistentExpressionStateForLanguage(
+            lldb::eLanguageTypeSwift));
 
     llvm::SmallVector<size_t, 1> declaration_indexes;
     parsed_expr->code_manipulator->FindVariableDeclarations(declaration_indexes,
@@ -2117,8 +2120,9 @@ SwiftExpressionParser::Parse(DiagnosticManager &diagnostic_manager,
     module_name = module->getName().get();
   m_swift_ast_ctx.CacheModule(module_name, module);
   if (m_sc.target_sp) {
-    auto *persistent_state =
-        m_sc.target_sp->GetSwiftPersistentExpressionState(*m_exe_scope);
+    auto *persistent_state = llvm::cast<SwiftPersistentExpressionState>(
+        m_sc.target_sp->GetPersistentExpressionStateForLanguage(
+            lldb::eLanguageTypeSwift));
     persistent_state->CopyInSwiftPersistentDecls(
         parsed_expr->external_lookup.GetStagedDecls());
   }

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

@@ -87,8 +87,8 @@ lldb::REPLSP SwiftREPL::CreateInstanceFromTarget(Status &err, Target &target,
   }
 
   // Check that we can get a type system, or we aren't going anywhere:
-  auto type_system_or_err = target.GetScratchTypeSystemForLanguage(
-      eLanguageTypeSwift, true, repl_options ? repl_options : "");
+  auto type_system_or_err =
+      target.GetScratchTypeSystemForLanguage(eLanguageTypeSwift, true);
   if (!type_system_or_err) {
     llvm::consumeError(type_system_or_err.takeError());
     err = Status::FromErrorString("Could not construct an expression "
@@ -260,8 +260,8 @@ lldb::REPLSP SwiftREPL::CreateInstanceFromDebugger(Status &err,
   // Check that we can get a type system, or we aren't
   // going anywhere.  Remember to pass in the repl_options
   // in case they set up framework paths we need, etc.
-  auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage(
-      eLanguageTypeSwift, true, repl_options ? repl_options : "");
+  auto type_system_or_err =
+      target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeSwift, true);
   if (!type_system_or_err) {
     llvm::consumeError(type_system_or_err.takeError());
     err = Status::FromErrorString("Could not construct an expression "
@@ -301,14 +301,13 @@ SwiftREPL::SwiftREPL(Target &target) : REPL(target), m_swift_ast(nullptr) {}
 SwiftREPL::~SwiftREPL() {}
 
 Status SwiftREPL::DoInitialization() {
-  if (m_compiler_options.empty())
-    return Status();
-
   auto type_system_or_err =
-      m_target.GetScratchTypeSystemForLanguage(eLanguageTypeSwift, true,
-                                               m_compiler_options.c_str());
+      m_target.GetScratchTypeSystemForLanguage(eLanguageTypeSwift, true);
   if (!type_system_or_err)
     return Status::FromError(type_system_or_err.takeError());
+  std::static_pointer_cast<TypeSystemSwiftTypeRefForExpressions>(
+      *type_system_or_err)
+      ->SetCompilerOptions(m_compiler_options.c_str());
   return Status();
 }
 
@@ -567,22 +566,29 @@ SwiftASTContextForExpressions *SwiftREPL::getSwiftASTContext() {
   // to fix this issue currently, so we need to work around it by making
   // our own copy of the AST and using this separate AST for completion.
   //----------------------------------------------------------------------
-  if (!m_swift_ast) {
-    auto type_system_or_err =
-        m_target.GetScratchTypeSystemForLanguage(eLanguageTypeSwift);
-    if (!type_system_or_err) {
-      llvm::consumeError(type_system_or_err.takeError());
-      return nullptr;
-    }
-    auto *swift_ts =
-        llvm::dyn_cast_or_null<TypeSystemSwiftTypeRefForExpressions>(
-            type_system_or_err->get());
-    auto *target_swift_ast =
-        llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(
-            swift_ts->GetSwiftASTContext(SymbolContext(
-                m_target.shared_from_this(), m_target.GetExecutableModule())));
-    m_swift_ast = target_swift_ast;
+  if (m_swift_ast)
+    return m_swift_ast;
+
+  auto type_system_or_err =
+      m_target.GetScratchTypeSystemForLanguage(eLanguageTypeSwift, false);
+  if (!type_system_or_err) {
+    llvm::consumeError(type_system_or_err.takeError());
+    return nullptr;
   }
+  auto *swift_ts = llvm::dyn_cast_or_null<TypeSystemSwiftTypeRefForExpressions>(
+      type_system_or_err->get());
+
+  // Use the stdlib as symbol context to get a different one than the main REPL.
+  SymbolContextList sc_list;
+  m_target.GetImages().FindSymbolsWithNameAndType(ConstString("_swift_release"),
+                                                  eSymbolTypeAny, sc_list);
+  if (!sc_list.GetSize())
+    return nullptr;
+
+  auto *target_swift_ast =
+      llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(
+          swift_ts->GetSwiftASTContext(sc_list[0]));
+  m_swift_ast = target_swift_ast;
   return m_swift_ast;
 }
 

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

@@ -503,14 +503,6 @@ static llvm::Error RegisterAllVariables(
   return llvm::Error::success();
 }
 
-static SwiftPersistentExpressionState *
-GetPersistentState(Target *target, ExecutionContext &exe_ctx) {
-  auto exe_scope = exe_ctx.GetBestExecutionContextScope();
-  if (!exe_scope)
-    return nullptr;
-  return target->GetSwiftPersistentExpressionState(*exe_scope);
-}
-
 /// Check if we can evaluate the expression as generic.
 /// Currently, evaluating expression as a generic has several limitations:
 /// - Only self will be evaluated with unbound generics.
@@ -727,12 +719,19 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
 
   exe_scope = exe_ctx.GetBestExecutionContextScope();
 
-  m_swift_scratch_ctx = target->GetSwiftScratchContext(
-      m_err, *exe_scope, /*create_on_demand=*/true,
-      m_options.GetPlaygroundTransformEnabled());
-  if (!m_swift_scratch_ctx)
+  auto ts_or_err = target->GetScratchTypeSystemForLanguage(
+      lldb::eLanguageTypeSwift, /*create_on_demand=*/true);
+  if (!ts_or_err)
     return error("could not create a Swift scratch context: ",
-                 m_err.AsCString());
+                 llvm::toString(ts_or_err.takeError()).c_str());
+  m_swift_scratch_ctx =
+      std::static_pointer_cast<TypeSystemSwiftTypeRefForExpressions>(
+          *ts_or_err);
+  if (!m_swift_scratch_ctx)
+    return error("could not create a Swift scratch context: ", "unknown error");
+  // Notify SwiftASTContext that this is a Playground.
+  if (m_options.GetPlaygroundTransformEnabled())
+    m_swift_scratch_ctx->SetCompilerOptions("");
 
   // For playgrounds, the target triple should be used for expression
   // evaluation, not the current module. This requires disabling precise
@@ -757,7 +756,8 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
   }
 
   // This may destroy the scratch context.
-  auto *persistent_state = GetPersistentState(target, exe_ctx);
+  auto *persistent_state =
+      target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeSwift);
   if (!persistent_state)
     return error("could not start parsing (no persistent data)");
 
@@ -898,8 +898,10 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
       // We currently key off there being more than one external
       // function in the execution unit to determine whether it needs
       // to live in the process.
-      GetPersistentState(exe_ctx.GetTargetPtr(), exe_ctx)
-          ->RegisterExecutionUnit(m_execution_unit_sp);
+      if (auto *target = exe_ctx.GetTargetPtr())
+        if (auto *state = target->GetPersistentExpressionStateForLanguage(
+                lldb::eLanguageTypeSwift))
+          state->RegisterExecutionUnit(m_execution_unit_sp);
     }
   }
 
@@ -975,7 +977,8 @@ lldb::ExpressionVariableSP SwiftUserExpression::GetResultAfterDematerialization(
 
     if (target_sp) {
       if (auto *persistent_state =
-              target_sp->GetSwiftPersistentExpressionState(*exe_scope)) {
+              target_sp->GetPersistentExpressionStateForLanguage(
+                  lldb::eLanguageTypeSwift)) {
         if (error_is_valid) {
           persistent_state->RemovePersistentVariable(in_result_sp);
           result_sp = in_error_sp;

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

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

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

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

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

@@ -291,8 +291,9 @@ HashedCollectionConfig::StorageObjectAtAddress(
   // same address.
   Status error;
   ExecutionContextScope *exe_scope = exe_ctx.GetBestExecutionContextScope();
-  auto scratch_ctx =
-      process_sp->GetTarget().GetSwiftScratchContext(error, *exe_scope);
+
+  auto scratch_ctx = TypeSystemSwiftTypeRefForExpressions::GetForTarget(
+      process_sp->GetTarget());
   if (!scratch_ctx)
     return nullptr;
   if (error.Fail())

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

@@ -1055,7 +1055,8 @@ SwiftLanguage::GetHardcodedSynthetics() {
         LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
                        "Could not get the swift runtime.");
 
-      auto ts = valobj.GetSwiftScratchContext();
+      auto ts = TypeSystemSwiftTypeRefForExpressions::GetForTarget(
+          valobj.GetTargetSP());
       if (!ts) {
         LLDB_LOGV(log, "[Matching CxxBridgedSyntheticChildProvider] - "
                        "Could not get the Swift scratch context.");
@@ -1347,28 +1348,24 @@ std::unique_ptr<Language::TypeScavenger> SwiftLanguage::GetTypeScavenger() {
           size_t before = results.size();
 
           if (exe_scope) {
-            Target *target = exe_scope->CalculateTarget().get();
-            if (target) {
-              const bool create_on_demand = false;
-              Status error;
-              auto scratch_ctx = target->GetSwiftScratchContext(
-                  error, *exe_scope, create_on_demand);
-              if (auto frame_sp = exe_scope->CalculateStackFrame()) {
-                auto &sc =
-                    frame_sp->GetSymbolContext(lldb::eSymbolContextFunction);
-                if (scratch_ctx)
-                  if (SwiftASTContext *ast_ctx =
-                          scratch_ctx->GetSwiftASTContext(sc)) {
-                    ConstString cs_input{input};
-                    Mangled mangled(cs_input);
-                    if (mangled.GuessLanguage() == eLanguageTypeSwift) {
-                      auto candidate =
-                          ast_ctx->GetTypeFromMangledTypename(cs_input);
-                      if (candidate.IsValid())
-                        results.insert(candidate);
-                    }
+            TargetSP target = exe_scope->CalculateTarget();
+            auto scratch_ctx =
+                TypeSystemSwiftTypeRefForExpressions::GetForTarget(target);
+            if (auto frame_sp = exe_scope->CalculateStackFrame()) {
+              auto &sc =
+                  frame_sp->GetSymbolContext(lldb::eSymbolContextFunction);
+              if (scratch_ctx)
+                if (SwiftASTContext *ast_ctx =
+                        scratch_ctx->GetSwiftASTContext(sc)) {
+                  ConstString cs_input{input};
+                  Mangled mangled(cs_input);
+                  if (mangled.GuessLanguage() == eLanguageTypeSwift) {
+                    auto candidate =
+                        ast_ctx->GetTypeFromMangledTypename(cs_input);
+                    if (candidate.IsValid())
+                      results.insert(candidate);
                   }
-              }
+                }
             }
           }
 
@@ -1420,11 +1417,9 @@ std::unique_ptr<Language::TypeScavenger> SwiftLanguage::GetTypeScavenger() {
           size_t before = results.size();
 
           if (exe_scope) {
-            Target *target = exe_scope->CalculateTarget().get();
-            const bool create_on_demand = false;
-            Status error;
-            auto scratch_ctx = target->GetSwiftScratchContext(error, *exe_scope,
-                                                              create_on_demand);
+            TargetSP target = exe_scope->CalculateTarget();
+            auto scratch_ctx =
+                TypeSystemSwiftTypeRefForExpressions::GetForTarget(target);
             if (auto frame_sp = exe_scope->CalculateStackFrame()) {
               const SymbolContext &sc =
                   frame_sp->GetSymbolContext(lldb::eSymbolContextFunction);