Merge pull request #8103 from adrian-prantl/bridging-progress

Add progress reports for bridging header compilation.

Author: adrian-prantl

lldb/include/lldb/Core/DebuggerEvents.h

@@ -7,6 +7,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/Progress.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/StructuredData.h"
 
@@ -39,7 +40,7 @@ class ProgressEventData : public EventData {
   GetAsStructuredData(const Event *event_ptr);
 
   uint64_t GetID() const { return m_id; }
-  bool IsFinite() const { return m_total != UINT64_MAX; }
+  bool IsFinite() const { return m_total != Progress::kNonDeterministicTotal; }
   uint64_t GetCompleted() const { return m_completed; }
   uint64_t GetTotal() const { return m_total; }
   std::string GetMessage() const {

lldb/include/lldb/Core/Progress.h

@@ -93,6 +93,9 @@ class Progress {
   void Increment(uint64_t amount = 1,
                  std::optional<std::string> updated_detail = {});
 
+  /// Used to indicate a non-deterministic progress report
+  static constexpr uint64_t kNonDeterministicTotal = UINT64_MAX;
+
 private:
   void ReportProgress();
   static std::atomic<uint64_t> g_id;

lldb/source/Core/DebuggerEvents.cpp

@@ -9,6 +9,7 @@
 #include "lldb/Core/DebuggerEvents.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Module.h"
+#include "lldb/Core/Progress.h"
 #include "llvm/Support/WithColor.h"
 
 using namespace lldb_private;
@@ -41,7 +42,7 @@ void ProgressEventData::Dump(Stream *s) const {
     s->PutCString(", type = update");
   // If m_total is UINT64_MAX, there is no progress to report, just "start"
   // and "end". If it isn't we will show the completed and total amounts.
-  if (m_total != UINT64_MAX)
+  if (m_total != Progress::kNonDeterministicTotal)
     s->Printf(", progress = %" PRIu64 " of %" PRIu64, m_completed, m_total);
 }
 

lldb/source/Core/Progress.cpp

@@ -22,8 +22,7 @@ Progress::Progress(std::string title, std::string details,
                    std::optional<uint64_t> total,
                    lldb_private::Debugger *debugger)
     : m_title(title), m_details(details), m_id(++g_id), m_completed(0),
-      m_total(1) {
-  assert(total == std::nullopt || total > 0);
+      m_total(Progress::kNonDeterministicTotal) {
   if (total)
     m_total = *total;
 

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

@@ -2060,16 +2060,19 @@ SwiftASTContext::CreateInstance(lldb::LanguageType language, Module &module,
     // swift::ASTContext
     Progress progress("Importing Swift standard library");
     swift_ast_sp->m_ast_context_ap->SetPreModuleImportCallback(
-        [&progress](llvm::StringRef module_name, bool is_overlay) {
-          progress.Increment(1, (is_overlay ? module_name.str() + " (overlay)"
-                                            : module_name.str()));
+        [&progress](llvm::StringRef module_name,
+                    swift::ASTContext::ModuleImportKind kind) {
+          progress.Increment(1, (kind == swift::ASTContext::Overlay
+                                     ? module_name.str() + " (overlay)"
+                                     : module_name.str()));
         });
 
     // Clear the callback function on scope exit to prevent an out-of-scope
     // access of the progress local variable
     auto on_exit = llvm::make_scope_exit([&]() {
       swift_ast_sp->m_ast_context_ap->SetPreModuleImportCallback(
-          [](llvm::StringRef module_name, bool is_overlay) {
+          [](llvm::StringRef module_name,
+             swift::ASTContext::ModuleImportKind kind) {
             Progress("Importing Swift modules");
           });
     });
@@ -2569,19 +2572,22 @@ lldb::TypeSystemSP SwiftASTContext::CreateInstance(
     const bool can_create = true;
 
     // Report progress on module importing by using a callback function in
-    // swift::ASTContext
+    // swift::ASTContext.
     Progress progress("Importing Swift standard library");
     swift_ast_sp->m_ast_context_ap->SetPreModuleImportCallback(
-        [&progress](llvm::StringRef module_name, bool is_overlay) {
-          progress.Increment(1, (is_overlay ? module_name.str() + " (overlay)"
-                                            : module_name.str()));
+        [&progress](llvm::StringRef module_name,
+                    swift::ASTContext::ModuleImportKind kind) {
+          progress.Increment(1, (kind == swift::ASTContext::Overlay
+                                     ? module_name.str() + " (overlay)"
+                                     : module_name.str()));
         });
 
     // Clear the callback function on scope exit to prevent an out-of-scope
-    // access of the progress local variable
+    // access of the progress local variable.
     auto on_exit = llvm::make_scope_exit([&]() {
       swift_ast_sp->m_ast_context_ap->SetPreModuleImportCallback(
-          [](llvm::StringRef module_name, bool is_overlay) {
+          [](llvm::StringRef module_name,
+             swift::ASTContext::ModuleImportKind kind) {
             Progress("Importing Swift modules");
           });
     });
@@ -3627,19 +3633,31 @@ swift::ModuleDecl *SwiftASTContext::GetModule(const SourceModule &module,
   auto import_diags = getScopedDiagnosticConsumer();
 
   // Report progress on module importing by using a callback function in
-  // swift::ASTContext
+  // swift::ASTContext.
   Progress progress("Importing Swift modules");
-  ast->SetPreModuleImportCallback([&progress](llvm::StringRef module_name,
-                                              bool is_overlay) {
-    progress.Increment(
-        1, (is_overlay ? module_name.str() + " (overlay)" : module_name.str()));
-  });
+  ast->SetPreModuleImportCallback(
+      [&progress](llvm::StringRef module_name,
+                  swift::ASTContext::ModuleImportKind kind) {
+        switch (kind) {
+        case swift::ASTContext::Module:
+          progress.Increment(1, module_name.str());
+          break;
+        case swift::ASTContext::Overlay:
+          progress.Increment(1, module_name.str() + " (overlay)");
+          break;
+        case swift::ASTContext::BridgingHeader:
+          progress.Increment(1,
+                             "Compiling bridging header: " + module_name.str());
+          break;
+        }
+      });
 
   // Clear the callback function on scope exit to prevent an out-of-scope access
   // of the progress local variable
   auto on_exit = llvm::make_scope_exit([&]() {
     ast->SetPreModuleImportCallback(
-        [](llvm::StringRef module_name, bool is_overlay) {
+        [](llvm::StringRef module_name,
+           swift::ASTContext::ModuleImportKind kind) {
           Progress("Importing Swift modules");
         });
   });

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

@@ -2830,7 +2830,8 @@ TypeSystemSwiftTypeRef::GetBitSize(opaque_compiler_type_t type,
       // pointer instead of the underlying object.
       if (Flags(clang_type.GetTypeInfo()).AllSet(eTypeIsObjC | eTypeIsClass))
         return GetPointerByteSize() * 8;
-      return clang_type.GetBitSize(exe_scope);
+      if (auto clang_size = clang_type.GetBitSize(exe_scope))
+        return clang_size;
     }
     if (!exe_scope) {
       LLDB_LOGF(GetLog(LLDBLog::Types),
@@ -4253,7 +4254,8 @@ TypeSystemSwiftTypeRef::GetTypeBitAlign(opaque_compiler_type_t type,
     // object pointer instead of the underlying object.
     if (Flags(clang_type.GetTypeInfo()).AllSet(eTypeIsObjC | eTypeIsClass))
       return GetPointerByteSize() * 8;
-    return clang_type.GetTypeBitAlign(exe_scope);
+    if (auto clang_align = clang_type.GetTypeBitAlign(exe_scope))
+      return clang_align;
   }
   if (!exe_scope) {
     LLDB_LOGF(GetLog(LLDBLog::Types),
@@ -4264,7 +4266,8 @@ TypeSystemSwiftTypeRef::GetTypeBitAlign(opaque_compiler_type_t type,
   }
   if (auto *runtime =
           SwiftLanguageRuntime::Get(exe_scope->CalculateProcess())) {
-    if (auto result = runtime->GetBitAlignment({weak_from_this(), type}, exe_scope))
+    if (auto result =
+            runtime->GetBitAlignment({weak_from_this(), type}, exe_scope))
       return result;
     // If this is an expression context, perhaps the type was
     // defined in the expression. In that case we don't have debug

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

@@ -1,5 +1,6 @@
 SWIFT_SOURCES := main.swift
-
+SWIFT_BRIDGING_HEADER := bridging.h
+SWIFT_PRECOMPILE_BRIDGING_HEADER := YES
 LD_EXTRAS := -L. -linvisible
 SWIFTFLAGS_EXTRAS := -I.
 

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

@@ -36,6 +36,7 @@ def test_swift_progress_report(self):
 
         beacons = [
             "Loading Swift module",
+            "Compiling bridging header",
             "Importing modules used in expression",
             "Setting up Swift reflection",
             "Importing Swift module dependencies for main.swift",

lldb/test/API/functionalities/progress_reporting/swift_progress_reporting/bridging.h

@@ -0,0 +1 @@
+struct FromBridgingHeader {};

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

@@ -4,6 +4,7 @@ import Foundation
 func main() {
   let boo = Invisible.👻()
   let s = NSAttributedString(string: "Hello")
+  let b = FromBridgingHeader()
   print("break here")
 }