[lldb] Restore Playground functionality

Playgrounds is setting a breakpoint in the PlaygroundStub executable,
which has no debug info and is implemented in C. Before
b5a1d34, LLDB would have done an
expensive and fragile scan through all images to find any Swift
modules and make them available. We stopped doing that because it
caused performance and correctness problems in Objective-C code that
interacted with Swift. However, avoiding the global scan also breaks
Playground's ability to find auxiliary source code.

This patch restores the original behavior when
SwiftASTContextForExpressions is initialized for a Playground only.

rdar://154373965

Author: adrian-prantl

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

@@ -302,7 +302,8 @@ Status SwiftREPL::DoInitialization() {
     return Status::FromError(type_system_or_err.takeError());
   std::static_pointer_cast<TypeSystemSwiftTypeRefForExpressions>(
       *type_system_or_err)
-      ->SetCompilerOptions(m_compiler_options.c_str());
+      ->SetCompilerOptions(/*repl=*/true, /*playgrounds=*/false,
+                           m_compiler_options.c_str());
 
   std::string format_str = "${ansi.negative}Swift " +
                            swift::version::getCompilerVersion() +

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

@@ -805,7 +805,9 @@ bool SwiftUserExpression::Parse(DiagnosticManager &diagnostic_manager,
                  "unknown error");
   // Notify SwiftASTContext that this is a Playground.
   if (m_options.GetPlaygroundTransformEnabled())
-    m_swift_scratch_ctx->SetCompilerOptions("");
+    m_swift_scratch_ctx->SetCompilerOptions(
+        m_options.GetREPLEnabled(), m_options.GetPlaygroundTransformEnabled(),
+        "");
 
   // For playgrounds, the target triple should be used for expression
   // evaluation, not the current module. This requires disabling precise

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

@@ -2689,16 +2689,14 @@ static lldb::ModuleSP GetUnitTestModule(lldb_private::ModuleList &modules) {
   return ModuleSP();
 }
 
-lldb::TypeSystemSP
-SwiftASTContext::CreateInstance(const SymbolContext &sc,
-                                TypeSystemSwiftTypeRef &typeref_typesystem,
-                                const char *extra_options) {
-  bool is_repl = extra_options;
+lldb::TypeSystemSP SwiftASTContext::CreateInstance(
+    const SymbolContext &sc, TypeSystemSwiftTypeRef &typeref_typesystem,
+    bool repl, bool playground, const char *extra_options) {
   bool for_expressions =
       llvm::isa<TypeSystemSwiftTypeRefForExpressions>(&typeref_typesystem);
   // REPL requires an expression type system.
-  assert(!is_repl || for_expressions);
-  if (is_repl && !for_expressions)
+  assert(!repl || for_expressions);
+  if (repl && !for_expressions)
     return {};
 
   if (!ModuleList::GetGlobalModuleListProperties()
@@ -2725,9 +2723,6 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
 
   LLDB_SCOPED_TIMERF("%s::CreateInstance", m_description.c_str());
 
-  if (is_repl)
-    LOG_PRINTF(GetLog(LLDBLog::Types), "REPL detected");
-
   // This function can either create an expression/scratch/repl context,
   // or a SwiftAST fallback context for a TypeSystemSwiftTyperef.
   // - SwiftASTContexForExpressions: target=non-null, module=null.
@@ -2771,8 +2766,9 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
     if (ShouldEnableEmbeddedSwift(cu))
       lang_opts.enableFeature(swift::Feature::Embedded);
   }
-  auto defer_log = llvm::make_scope_exit(
-      [swift_ast_sp, is_repl] { swift_ast_sp->LogConfiguration(is_repl); });
+  auto defer_log = llvm::make_scope_exit([swift_ast_sp, repl, playground] {
+    swift_ast_sp->LogConfiguration(repl, playground);
+  });
 
   LOG_PRINTF(GetLog(LLDBLog::Types), "(Target)");
   auto logError = [&](const char *message) {
@@ -2798,8 +2794,12 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
   ModuleList module_module;
   if (!target_sp)
     module_module.Append(module_sp);
-  ModuleList &modules =
-      (target_sp && swift_context) ? target_sp->GetImages() : module_module;
+  // Leave modules empty if not in a Swift context to avoid a fragile
+  // and expensive scan through all images. Unless this is a Playground, which
+  // has a non-Swift executable, and user code in a framework.
+  ModuleList &modules = (target_sp && (swift_context || playground))
+                            ? target_sp->GetImages()
+                            : module_module;
   const size_t num_images = modules.GetSize();
 
   // Set the SDK path prior to doing search paths.  Otherwise when we
@@ -2871,7 +2871,7 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
 
     ArchSpec preferred_arch;
     llvm::Triple preferred_triple;
-    if (is_repl) {
+    if (repl) {
       LOG_PRINTF(GetLog(LLDBLog::Types), "REPL: prefer target triple.");
       preferred_arch = target_arch;
       preferred_triple = target_triple;
@@ -3135,7 +3135,7 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
           }
         }
       };
-  if (swift_context)
+  if (swift_context || playground)
     scan_module(module_sp, 0);
   for (size_t mi = 0; mi != num_images; ++mi) {
     auto image_sp = modules.GetModuleAtIndex(mi);
@@ -5464,7 +5464,7 @@ void SwiftASTContext::ClearModuleDependentCaches() {
   m_negative_type_cache.Clear();
 }
 
-void SwiftASTContext::LogConfiguration(bool is_repl) {
+void SwiftASTContext::LogConfiguration(bool repl, bool playground) {
   // It makes no sense to call VALID_OR_RETURN here. We specifically
   // want the logs in the error case!
   HEALTH_LOG_PRINTF("(SwiftASTContext*)%p:", static_cast<void *>(this));
@@ -5474,8 +5474,10 @@ void SwiftASTContext::LogConfiguration(bool is_repl) {
     HEALTH_LOG_PRINTF("  (no AST context)");
     return;
   }
-  if (is_repl)
+  if (repl)
     HEALTH_LOG_PRINTF("  REPL                             : true");
+  if (playground)
+    HEALTH_LOG_PRINTF("  Playground                       : true");
   HEALTH_LOG_PRINTF("  Swift/C++ interop                : %s",
                     ast_context->LangOpts.EnableCXXInterop ? "on" : "off");
   HEALTH_LOG_PRINTF("  Swift/Objective-C interop        : %s",

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

@@ -207,8 +207,8 @@ class SwiftASTContext : public TypeSystemSwift {
   /// context.
   static lldb::TypeSystemSP
   CreateInstance(const SymbolContext &sc,
-                 TypeSystemSwiftTypeRef &typeref_typesystem,
-                 const char *extra_options = nullptr);
+                 TypeSystemSwiftTypeRef &typeref_typesystem, bool repl = false,
+                 bool playground = false, const char *extra_options = nullptr);
 
   static void EnumerateSupportedLanguages(
       std::set<lldb::LanguageType> &languages_for_types,
@@ -539,7 +539,7 @@ class SwiftASTContext : public TypeSystemSwift {
   swift::TBDGenOptions &GetTBDGenOptions();
 
   void ClearModuleDependentCaches() override;
-  void LogConfiguration(bool is_repl = false);
+  void LogConfiguration(bool repl = false, bool playground = false);
   bool HasTarget();
   bool HasExplicitModules() const { return m_has_explicit_modules; }
   bool CheckProcessChanged();

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

@@ -45,8 +45,8 @@ static lldb::TypeSystemSP CreateTypeSystemInstance(lldb::LanguageType language,
   } else if (target) {
     assert(!module);
     return std::shared_ptr<TypeSystemSwiftTypeRefForExpressions>(
-        new TypeSystemSwiftTypeRefForExpressions(language, *target,
-                                                 extra_options));
+        new TypeSystemSwiftTypeRefForExpressions(language, *target, false,
+                                                 false, extra_options));
   }
   llvm_unreachable("Neither type nor module given to CreateTypeSystemInstance");
 }

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

@@ -1963,24 +1963,26 @@ TypeSystemSwiftTypeRef::TypeSystemSwiftTypeRef(Module &module) {
 }
 
 TypeSystemSwiftTypeRefForExpressions::TypeSystemSwiftTypeRefForExpressions(
-    lldb::LanguageType language, Target &target, const char *extra_options)
+    lldb::LanguageType language, Target &target, bool repl, bool playground,
+    const char *extra_options)
     : m_target_wp(target.shared_from_this()),
       m_persistent_state_up(new SwiftPersistentExpressionState) {
   m_description = "TypeSystemSwiftTypeRefForExpressions";
   LLDB_LOGF(GetLog(LLDBLog::Types),
             "%s::TypeSystemSwiftTypeRefForExpressions()",
             m_description.c_str());
   // Is this a REPL or Playground?
-  if (extra_options) {
+  assert(!repl && !playground && !extra_options && "use SetCompilerOptions()");
+  if (repl || playground || extra_options) {
     SymbolContext global_sc(target.shared_from_this(),
                             target.GetExecutableModule());
     const char *key = DeriveKeyFor(global_sc);
     m_swift_ast_context_map.insert(
         {key,
          {SwiftASTContext::CreateInstance(
               global_sc,
-              *const_cast<TypeSystemSwiftTypeRefForExpressions *>(this),
-              extra_options),
+              *const_cast<TypeSystemSwiftTypeRefForExpressions *>(this), repl,
+              playground, extra_options),
           0}});
   }
 }
@@ -2183,8 +2185,8 @@ SwiftASTContextSP TypeSystemSwiftTypeRefForExpressions::GetSwiftASTContext(
 
     // Create a new SwiftASTContextForExpressions.
     ts = SwiftASTContext::CreateInstance(
-        sc, *const_cast<TypeSystemSwiftTypeRefForExpressions *>(this),
-        m_compiler_options);
+        sc, *const_cast<TypeSystemSwiftTypeRefForExpressions *>(this), m_repl,
+        m_playground, m_compiler_options);
     m_swift_ast_context_map.insert({key, {ts, retry_count}});
   }
 

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h

@@ -626,7 +626,8 @@ class TypeSystemSwiftTypeRefForExpressions : public TypeSystemSwiftTypeRef {
   /// \}
 
   TypeSystemSwiftTypeRefForExpressions(lldb::LanguageType language,
-                                       Target &target,
+                                       Target &target, bool repl,
+                                       bool playground,
                                        const char *extra_options);
 
   static TypeSystemSwiftTypeRefForExpressionsSP GetForTarget(Target &target);
@@ -638,7 +639,10 @@ class TypeSystemSwiftTypeRefForExpressions : public TypeSystemSwiftTypeRef {
   GetSwiftASTContextOrNull(const SymbolContext &sc) const override;
   /// This API needs to be called for a REPL or Playground before the first call
   /// to GetSwiftASTContext is being made.
-  void SetCompilerOptions(const char *compiler_options) {
+  void SetCompilerOptions(bool repl, bool playground,
+                         const char *compiler_options) {
+    m_repl = repl;
+    m_playground = playground;
     m_compiler_options = compiler_options;
   }
   lldb::TargetWP GetTargetWP() const override { return m_target_wp; }
@@ -668,6 +672,8 @@ class TypeSystemSwiftTypeRefForExpressions : public TypeSystemSwiftTypeRef {
 protected:
   lldb::TargetWP m_target_wp;
   unsigned m_generation = 0;
+  bool m_repl = false;
+  bool m_playground = false;
   const char *m_compiler_options = nullptr;
 
   /// This exists to implement the PerformCompileUnitImports

lldb/test/API/lang/swift/playgrounds/AuxSources.swift

@@ -0,0 +1 @@
+// This file intentionally left blank.

lldb/test/API/lang/swift/playgrounds/Import.swift

@@ -1,3 +1,4 @@
+import AuxSources
 import Dylib
 f()
 let comment = "and back again"

lldb/test/API/lang/swift/playgrounds/Makefile

@@ -1,12 +1,14 @@
 EXE = PlaygroundStub
 SWIFT_SOURCES = PlaygroundStub.swift
+# The real playground stub has no debug info and is written in C.
+SWIFTFLAGS_EXTRAS = -gnone
 
 # The deployment target we set is pre-ABI stability. The Swift driver will not
 # point the RPATH at the system library. Do it manually.
 LD_EXTRAS := -Xlinker -rpath -Xlinker /usr/lib/swift
-LD_EXTRAS += -L. -lPlaygroundsRuntime
+LD_EXTRAS += -L. -lPlaygroundsRuntime -F. -framework AuxSources
 
-PlaygroundStub: libPlaygroundsRuntime.dylib Dylib.framework
+PlaygroundStub: libPlaygroundsRuntime.dylib Dylib.framework AuxSources.framework
 
 include Makefile.rules
 
@@ -21,3 +23,10 @@ Dylib.framework: Dylib.swift
 		DYLIB_SWIFT_SOURCES=Dylib.swift \
 		DYLIB_NAME=Dylib \
 		SWIFTFLAGS_EXTRAS="-Xcc -DNEW_OPTION_FROM_DYLIB=1"
+
+AuxSources.framework: AuxSources.swift
+	"$(MAKE)" -f $(MAKEFILE_RULES) \
+		FRAMEWORK=AuxSources \
+		DYLIB_SWIFT_SOURCES=AuxSources.swift \
+		DYLIB_NAME=AuxSources \
+		SWIFTFLAGS_EXTRAS="-Xcc -DHAVE_AUXSOURCES=1"