[lldb/swift] Add swift type-system progress reporting

This patch reports progress events specific to the swift type-system.

Currently, it covers 3 long-running operations:
- Setting up the runtime reflection context
- Loading implicit modules from the compile unit
- Caching them in the expression persistent state

It also includes a test a will listen for swift progress events and make
sure it we receive them when fetching a swift variable.

rdar://75803015

Signed-off-by: Med Ismail Bennani <[email protected]>

Author: medismailben

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp

@@ -21,6 +21,7 @@
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/JITSection.h"
 #include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Progress.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/DataFormatters/StringPrinter.h"
@@ -461,36 +462,52 @@ void SwiftLanguageRuntimeImpl::SetupReflection() {
     return;
 
   auto &target = m_process.GetTarget();
-  if (auto exe_module = target.GetExecutableModule()) {
-    bool objc_interop = (bool)findRuntime(m_process, RuntimeKind::ObjC);
-    const char *objc_interop_msg =
-        objc_interop ? "with Objective-C interopability" : "Swift only";
-
-    auto &triple = exe_module->GetArchitecture().GetTriple();
-    if (triple.isArch64Bit()) {
-      LLDB_LOGF(GetLog(LLDBLog::Types),
-                "Initializing a 64-bit reflection context (%s) for \"%s\"",
-                triple.str().c_str(), objc_interop_msg);
-      m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext64(
-          this->GetMemoryReader(), objc_interop);
-    } else if (triple.isArch32Bit()) {
-      LLDB_LOGF(GetLog(LLDBLog::Types),
-                "Initializing a 32-bit reflection context (%s) for \"%s\"",
-                triple.str().c_str(), objc_interop_msg);
-      m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext32(
-          this->GetMemoryReader(), objc_interop);
-    } else {
-      LLDB_LOGF(GetLog(LLDBLog::Types),
-                "Could not initialize reflection context for \"%s\"",
-                triple.str().c_str());
-    }
+  auto exe_module = target.GetExecutableModule();
+
+  if (!exe_module) {
+    LLDB_LOGF(GetLog(LLDBLog::Types), "%s: Failed to get executable module",
+              LLVM_PRETTY_FUNCTION);
+    m_initialized_reflection_ctx = false;
+    return;
   }
+
+  bool objc_interop = (bool)findRuntime(m_process, RuntimeKind::ObjC);
+  const char *objc_interop_msg =
+      objc_interop ? "with Objective-C interopability" : "Swift only";
+
+  auto &triple = exe_module->GetArchitecture().GetTriple();
+  if (triple.isArch64Bit()) {
+    LLDB_LOGF(GetLog(LLDBLog::Types),
+              "Initializing a 64-bit reflection context (%s) for \"%s\"",
+              triple.str().c_str(), objc_interop_msg);
+    m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext64(
+        this->GetMemoryReader(), objc_interop);
+  } else if (triple.isArch32Bit()) {
+    LLDB_LOGF(GetLog(LLDBLog::Types),
+              "Initializing a 32-bit reflection context (%s) for \"%s\"",
+              triple.str().c_str(), objc_interop_msg);
+    m_reflection_ctx = ReflectionContextInterface::CreateReflectionContext32(
+        this->GetMemoryReader(), objc_interop);
+  } else {
+    LLDB_LOGF(GetLog(LLDBLog::Types),
+              "Could not initialize reflection context for \"%s\"",
+              triple.str().c_str());
+  }
+
   m_initialized_reflection_ctx = true;
 
+  Progress progress(
+      llvm::formatv("Setting up Swift reflection for '{0}'",
+                    exe_module->GetFileSpec().GetFilename().AsCString()),
+      m_modules_to_add.GetSize());
+
+  size_t completion = 0;
+
   // Add all defered modules to reflection context that were added to
   // the target since this SwiftLanguageRuntime was created.
   m_modules_to_add.ForEach([&](const ModuleSP &module_sp) -> bool {
     AddModuleToReflectionContext(module_sp);
+    progress.Increment(++completion);
     return true;
   });
   m_modules_to_add.Clear();

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

@@ -95,6 +95,7 @@
 #include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/Progress.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
@@ -3999,9 +4000,20 @@ void SwiftASTContext::ValidateSectionModules(
 
   Status error;
 
+  Progress progress(
+      llvm::formatv("Loading Swift module {0}",
+                    module.GetFileSpec().GetFilename().AsCString()),
+      module_names.size());
+
+  size_t completion = 0;
+
   for (const std::string &module_name : module_names) {
     SourceModule module_info;
     module_info.path.push_back(ConstString(module_name));
+
+    // We have to increment the completion value even if we can't get the module
+    // object to stay in-sync with the total progress reporting.
+    progress.Increment(++completion);
     if (!GetModule(module_info, error))
       module.ReportWarning("unable to load swift module \"%s\" (%s)",
                            module_name.c_str(), error.AsCString());
@@ -8253,9 +8265,17 @@ bool SwiftASTContext::CacheUserImports(SwiftASTContext &swift_ast_context,
   auto *persistent_expression_state =
       sc.target_sp->GetSwiftPersistentExpressionState(exe_scope);
 
-  for (const auto &attributed_import : source_file.getImports()) {
-    swift::ModuleDecl *module = attributed_import.module.importedModule;
+  auto src_file_imports = source_file.getImports();
+
+  Progress progress(llvm::formatv("Caching Swift user imports from '{0}'",
+                                  source_file.getFilename().data()),
+                    src_file_imports.size());
 
+  size_t completion = 0;
+
+  for (const auto &attributed_import : src_file_imports) {
+    progress.Increment(++completion);
+    swift::ModuleDecl *module = attributed_import.module.importedModule;
     if (module) {
       std::string module_name;
       GetNameFromModule(module, module_name);
@@ -8331,7 +8351,16 @@ bool SwiftASTContext::GetCompileUnitImportsImpl(
   if (!compile_unit || compile_unit->GetLanguage() != lldb::eLanguageTypeSwift)
     return true;
 
-  for (const SourceModule &module : compile_unit->GetImportedModules()) {
+  auto cu_imports = compile_unit->GetImportedModules();
+
+  Progress progress(
+      llvm::formatv("Getting Swift compile unit imports for '{0}'",
+                    compile_unit->GetPrimaryFile().GetFilename()),
+      cu_imports.size());
+
+  size_t completion = 0;
+  for (const SourceModule &module : cu_imports) {
+    progress.Increment(++completion);
     // When building the Swift stdlib with debug info these will
     // show up in "Swift.o", but we already imported them and
     // manually importing them will fail.

lldb/test/API/functionalities/progress_reporting/swift_progress_reporting/Makefile

@@ -0,0 +1,3 @@
+SWIFT_SOURCES := main.swift
+
+include Makefile.rules

lldb/test/API/functionalities/progress_reporting/swift_progress_reporting/TestSwiftProgressReporting.py

@@ -0,0 +1,43 @@
+"""
+Test that we are able to broadcast and receive swift progress events from lldb
+"""
+import lldb
+
+import lldbsuite.test.lldbutil as lldbutil
+
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from lldbsuite.test.eventlistener import EventListenerTestBase
+
+class TestSwiftProgressReporting(EventListenerTestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    event_mask = lldb.SBDebugger.eBroadcastBitProgress
+    event_data_extractor = lldb.SBDebugger.GetProgressFromEvent
+
+    @swiftTest
+    def test_swift_progress_report(self):
+        """Test that we are able to fetch swift type-system progress events"""
+        self.build()
+
+        target, process, thread, _ = lldbutil.run_to_source_breakpoint(self, 'break here',
+                                          lldb.SBFileSpec('main.swift'))
+
+        self.assertGreater(thread.GetNumFrames(), 0)
+        frame = thread.GetSelectedFrame()
+        self.assertTrue(frame, "Invalid frame.")
+
+        # Resolve variable to exercise the type-system
+        self.runCmd("expr numbers")
+
+        self.assertGreater(len(self.events), 0)
+
+        beacons = [ "Loading Swift module",
+                    "Caching Swift user imports from",
+                    "Setting up Swift reflection for",
+                    "Getting Swift compile unit imports for"]
+
+        for beacon in beacons:
+            filtered_events = list(filter(lambda event: beacon in event[0],
+                                          self.events))
+            self.assertGreater(len(filtered_events), 0)

lldb/test/API/functionalities/progress_reporting/swift_progress_reporting/main.swift

@@ -0,0 +1,49 @@
+struct IntPair {
+  var original: Int
+  var opposite: Int
+
+  init(_ value: Int) {
+    self.original = value
+    self.opposite = -value
+  }
+}
+
+enum Toggle { case On; case Off }
+
+enum ColorCode {
+  case RGB(UInt8, UInt8, UInt8)
+  case Hex(Int)
+}
+
+protocol Flyable {
+  var fly : String { get }
+}
+
+struct Bird: Flyable {
+  var fly: String = "🦅"
+}
+
+struct Plane: Flyable {
+  var fly: String = "🛩"
+}
+
+class Number<T:Numeric> {
+  var number_value : T
+
+  init (number value : T) {
+    number_value = value
+  }
+}
+
+func main() {
+  let structArray = [ IntPair(1), IntPair(-2), IntPair(3) ]
+  var enumArray = [ Toggle.Off ]
+  var colors = [ColorCode.RGB(155,219,255), ColorCode.Hex(0x4545ff)]
+  var flyingObjects : [Flyable] = [ Bird(), Plane() ]
+  let numbers = [ Number(number: 42), Number(number: 3.14)]
+  let bytes = [UInt8](0...255)
+  var bits : [UInt8] = [0,1]
+  print("break here")
+}
+
+main()