Remove classic whole-project compiler invocations.

This feature was off-by default in Swift 6.0
This patch completes the transition to precise compiler invocations by removing the backwards-compatibility.

The many test updates are for tests that were checking for the old behavior (which was still present in the tests due to the typeref-typesystem validation creating an classic-mode scratch context).

Author: adrian-prantl

lldb/include/lldb/Core/ModuleList.h

@@ -80,13 +80,10 @@ class ModuleListProperties : public Properties {
   bool GetUseSwiftClangImporter() const;
   bool GetUseSwiftDWARFImporter() const;
   bool SetUseSwiftDWARFImporter(bool new_value);
-  bool GetUseSwiftTypeRefTypeSystem() const;
-  bool SetUseSwiftTypeRefTypeSystem(bool new_value);
   bool GetSwiftValidateTypeSystem() const;
   SwiftModuleLoadingMode GetSwiftModuleLoadingMode() const;
   bool SetSwiftModuleLoadingMode(SwiftModuleLoadingMode);
 
-  bool GetUseSwiftPreciseCompilerInvocation() const;
   bool GetEnableSwiftMetadataCache() const;
   uint64_t GetSwiftMetadataCacheMaxByteSize();
   uint64_t GetSwiftMetadataCacheExpirationDays();

lldb/include/lldb/Target/Target.h

@@ -1301,7 +1301,8 @@ class Target : public std::enable_shared_from_this<Target>,
 
   std::optional<SwiftScratchContextReader>
   GetSwiftScratchContext(Status &error, ExecutionContextScope &exe_scope,
-                         bool create_on_demand = true);
+                         bool create_on_demand = true,
+                         bool for_playground = false);
 
   /// Return whether this is the Swift REPL.
   bool IsSwiftREPL();

lldb/source/Core/CoreProperties.td

@@ -25,15 +25,9 @@ let Definition = "modulelist" in {
   def UseSwiftDWARFImporter: Property<"use-swift-dwarfimporter", "Boolean">,
     DefaultTrue,
     Desc<"Reconstruct Clang module dependencies from DWARF when debugging Swift code">;
-  def UseSwiftTypeRefTypeSystem: Property<"use-swift-typeref-typesystem", "Boolean">,
-    DefaultTrue,
-    Desc<"Prefer Swift Remote Mirrors over Remote AST">;
   def SwiftValidateTypeSystem: Property<"swift-validate-typesystem", "Boolean">,
     DefaultFalse,
     Desc<"Validate all Swift typesystem queries. Used for testing an asserts-enabled LLDB only.">;
-  def UseSwiftPreciseCompilerInvocation: Property<"swift-precise-compiler-invocation", "Boolean">,
-    DefaultTrue,
-    Desc<"In the Swift expression evaluator, create many Swift compiler instances with the precise invocation for the current context, instead of a single compiler instance that merges all flags from the entire project.">;
   def SwiftModuleLoadingMode: Property<"swift-module-loading-mode", "Enum">,
     DefaultEnumValue<"eSwiftModuleLoadingModePreferSerialized">,
     EnumValues<"OptionEnumValues(g_swift_module_loading_mode_enums)">,

lldb/source/Core/Module.cpp

@@ -1634,7 +1634,7 @@ bool Module::SetArchitecture(const ArchSpec &new_arch) {
 #ifdef LLDB_ENABLE_SWIFT
     if (auto ts =
             llvm::dyn_cast_or_null<TypeSystemSwift>(type_system_or_err->get()))
-      ts->SetTriple(new_arch.GetTriple());
+      ts->SetTriple(SymbolContext(shared_from_this()), new_arch.GetTriple());
 #endif // LLDB_ENABLE_SWIFT
     return true;
   }

lldb/source/Core/ModuleList.cpp

@@ -194,29 +194,12 @@ bool ModuleListProperties::SetUseSwiftDWARFImporter(bool new_value) {
   return SetPropertyAtIndex(idx, new_value);
 }
 
-bool ModuleListProperties::GetUseSwiftTypeRefTypeSystem() const {
-  const uint32_t idx = ePropertyUseSwiftTypeRefTypeSystem;
-  return GetPropertyAtIndexAs<bool>(
-      idx, g_modulelist_properties[idx].default_uint_value != 0);
-}
-
 bool ModuleListProperties::GetSwiftValidateTypeSystem() const {
   const uint32_t idx = ePropertySwiftValidateTypeSystem;
   return GetPropertyAtIndexAs<bool>(
       idx, g_modulelist_properties[idx].default_uint_value != 0);
 }
 
-bool ModuleListProperties::GetUseSwiftPreciseCompilerInvocation() const {
-  const uint32_t idx = ePropertyUseSwiftPreciseCompilerInvocation;
-  return GetPropertyAtIndexAs<bool>(
-      idx, g_modulelist_properties[idx].default_uint_value != 0);
-}
-
-bool ModuleListProperties::SetUseSwiftTypeRefTypeSystem(bool new_value) {
-  const uint32_t idx = ePropertyUseSwiftTypeRefTypeSystem;
-  return SetPropertyAtIndex(idx, new_value);
-}
-
 SwiftModuleLoadingMode ModuleListProperties::GetSwiftModuleLoadingMode() const {
   const uint32_t idx = ePropertySwiftModuleLoadingMode;
   return GetPropertyAtIndexAs<SwiftModuleLoadingMode>(

lldb/source/Expression/IRExecutionUnit.cpp

@@ -845,7 +845,7 @@ IRExecutionUnit::FindInSymbols(const std::vector<ConstString> &names,
       // BEGIN SWIFT
       if (m_in_populate_symtab)
         if (lldb::ModuleSP module_sp = m_jit_module_wp.lock())
-        images.Remove(module_sp);
+          images.Remove(module_sp);
       // END SWIFT
 
       SymbolContextList sc_list;

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

@@ -897,7 +897,7 @@ llvm::Expected<swift::Type> SwiftASTManipulator::GetSwiftTypeForVariable(
   // When injecting a value pack or pack count into the outer
   // lldb_expr function, treat it as an opaque raw pointer.
   if (m_bind_generic_types == lldb::eDontBind && variable.IsUnboundPack()) {
-    auto swift_ast_ctx = type_system_swift->GetSwiftASTContext(&m_sc);
+    auto swift_ast_ctx = type_system_swift->GetSwiftASTContext(m_sc);
     if (!swift_ast_ctx)
       return llvm::createStringError("no typesystem for variable " +
                                      variable.GetName().str());

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

@@ -569,7 +569,8 @@ void SwiftREPL::CompleteCode(const std::string &current_code,
             type_system_or_err->get());
     auto *target_swift_ast =
         llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(
-            swift_ts->GetSwiftASTContext(nullptr));
+            swift_ts->GetSwiftASTContext(SymbolContext(
+                m_target.shared_from_this(), m_target.GetExecutableModule())));
     m_swift_ast = target_swift_ast;
   }
   SwiftASTContextForExpressions *swift_ast = m_swift_ast;

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

@@ -721,25 +721,28 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
     return error("couldn't start parsing - no stack frame");
 
   ExecutionContextScope *exe_scope =
-      m_options.GetREPLEnabled() ? static_cast<ExecutionContextScope *>(target)
-                                 : static_cast<ExecutionContextScope *>(frame);
+      m_options.GetREPLEnabled() || m_options.GetPlaygroundTransformEnabled()
+          ? static_cast<ExecutionContextScope *>(target)
+          : static_cast<ExecutionContextScope *>(frame);
 
-exe_scope = exe_ctx.GetBestExecutionContextScope();
+  exe_scope = exe_ctx.GetBestExecutionContextScope();
 
-  m_swift_scratch_ctx = target->GetSwiftScratchContext(m_err, *exe_scope);
+  m_swift_scratch_ctx = target->GetSwiftScratchContext(
+      m_err, *exe_scope, /*create_on_demand=*/true,
+      m_options.GetPlaygroundTransformEnabled());
   if (!m_swift_scratch_ctx)
     return error("could not create a Swift scratch context: ",
                  m_err.AsCString());
 
   // For playgrounds, the target triple should be used for expression
   // evaluation, not the current module. This requires disabling precise
   // compiler invocations.
-  //
-  // To disable precise compiler invocations, pass a null SymbolContext.
-  const SymbolContext *sc = nullptr;
-  if (!m_runs_in_playground_or_repl)
-    sc = &frame->GetSymbolContext(lldb::eSymbolContextFunction);
-
+  SymbolContext sc;
+  if (m_options.GetREPLEnabled() || m_options.GetPlaygroundTransformEnabled())
+    sc = SymbolContext(target->shared_from_this(),
+                       target->GetExecutableModule());
+  else
+    sc = frame->GetSymbolContext(lldb::eSymbolContextFunction);
   auto *swift_ast_ctx = m_swift_scratch_ctx->get()->GetSwiftASTContext(sc);
   m_swift_ast_ctx =
       llvm::dyn_cast_or_null<SwiftASTContextForExpressions>(swift_ast_ctx);

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

@@ -103,7 +103,9 @@ static std::string TranslateObjCNameToSwiftName(std::string className,
   const SymbolContext *sc = nullptr;
   if (swiftFrame)
     sc = &swiftFrame->GetSymbolContext(eSymbolContextFunction);
-  auto *ctx = ts->GetSwiftASTContext(sc);
+  if (!sc)
+    return "";
+  auto *ctx = ts->GetSwiftASTContext(*sc);
   if (!ctx)
     return "";
   swift::ClangImporter *imp = ctx->GetClangImporter();