Merge pull request #10946 from adrian-prantl/154373965

[lldb] Restore Playground functionality

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()
@@ -2707,26 +2705,24 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
 
   CompileUnit *cu = sc.comp_unit;
   const char *key = TypeSystemSwiftTypeRef::DeriveKeyFor(sc);
+  bool swift_context = cu && cu->GetLanguage() == eLanguageTypeSwift;
   std::string m_description;
   {
     StreamString ss;
     ss << "SwiftASTContext";
     if (for_expressions)
       ss << "ForExpressions";
     ss << "(module: " << '"' << key << "\", " << "cu: " << '"';
-    if (cu)
+    if (cu && swift_context)
       ss << cu->GetPrimaryFile().GetFilename();
     else
-      ss << "null";
+      ss << "*";
     ss << '"' << ')';
     m_description = ss.GetString();
   }
 
   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.
@@ -2770,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) {
@@ -2797,7 +2794,12 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
   ModuleList module_module;
   if (!target_sp)
     module_module.Append(module_sp);
-  ModuleList &modules = target_sp ? 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
@@ -2869,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;
@@ -3133,7 +3135,8 @@ SwiftASTContext::CreateInstance(const SymbolContext &sc,
           }
         }
       };
-  scan_module(module_sp, 0);
+  if (swift_context || playground)
+    scan_module(module_sp, 0);
   for (size_t mi = 0; mi != num_images; ++mi) {
     auto image_sp = modules.GetModuleAtIndex(mi);
     if (!visited_modules.count(image_sp.get()))
@@ -5461,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));
@@ -5471,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}});
   }
 }
@@ -2072,15 +2074,14 @@ ConstString TypeSystemSwiftTypeRef::GetSwiftModuleFor(const SymbolContext &sc) {
 }
 
 const char *TypeSystemSwiftTypeRef::DeriveKeyFor(const SymbolContext &sc) {
-  if (sc.function)
+  if (sc.comp_unit && sc.comp_unit->GetLanguage() == eLanguageTypeSwift)
     if (ConstString name = GetSwiftModuleFor(sc))
       return name.GetCString();
 
-  if (sc.module_sp) {
-    if (sc.module_sp->GetFileSpec())
-      return sc.module_sp->GetFileSpec().GetFilename().GetCString();
-    return sc.module_sp->GetObjectName().GetCString();
-  }
+  // Otherwise create a catch-all context per unique triple.
+  if (sc.module_sp)
+    return ConstString(sc.module_sp->GetArchitecture().GetTriple().str()).AsCString();
+
   return nullptr;
 }
 
@@ -2184,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}});
   }
 
@@ -2563,6 +2564,9 @@ template <> bool Equivalent<CompilerType>(CompilerType l, CompilerType r) {
   ConstString rhs = r.GetMangledTypeName();
   if (lhs == ConstString("$sSiD") && rhs == ConstString("$sSuD"))
     return true;
+  if (lhs.GetStringRef() == "$sSPySo0023unnamedstruct_hEEEdhdEaVGSgD" &&
+      rhs.GetStringRef() == "$ss13OpaquePointerVSgD")
+    return true;
   // Ignore missing sugar.
   swift::Demangle::Demangler dem;
   auto l_node = GetDemangledType(dem, lhs.GetStringRef());

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"