Extend PreModuleImportCallback to support bridging header compilation

include/swift/AST/ASTContext.h

@@ -295,10 +295,19 @@ class ASTContext final {
   /// OutputBackend for writing outputs.
   llvm::IntrusiveRefCntPtr<llvm::vfs::OutputBackend> OutputBackend;
 
+  enum ModuleImportKind {
+    Module = 0,
+    Overlay,
+    BridgingHeader
+  };
+  using PreModuleImportCallbackPtr =
+      std::function<void(StringRef ModuleName, ModuleImportKind Kind)>;
   /// Set the callback function that is invoked before Swift module importing is
-  /// performed
-  void SetPreModuleImportCallback(
-      std::function<void(llvm::StringRef ModuleName, bool IsOverlay)> callback);
+  /// performed.
+  void SetPreModuleImportCallback(PreModuleImportCallbackPtr callback);
+
+  /// Call the PreModuleImportCallback. Used by ClangImporter.
+  void PreModuleImportHook(StringRef ModuleName, ModuleImportKind Kind) const;
 
   /// If the shared pointer is not a \c nullptr and the pointee is \c true,
   /// all operations working on this ASTContext should be aborted at the next
@@ -414,8 +423,7 @@ class ASTContext final {
   getAllocator(AllocationArena arena = AllocationArena::Permanent) const;
 
   /// An optional generic callback function invoked prior to importing a module.
-  mutable std::function<void(llvm::StringRef ModuleName, bool IsOverlay)>
-      PreModuleImportCallback;
+  mutable PreModuleImportCallbackPtr PreModuleImportCallback;
 
 public:
   /// Allocate - Allocate memory from the ASTContext bump pointer.

lib/AST/ASTContext.cpp

@@ -761,10 +761,16 @@ ASTContext::~ASTContext() {
 }
 
 void ASTContext::SetPreModuleImportCallback(
-    std::function<void(llvm::StringRef ModuleName, bool IsOverlay)> callback) {
+    PreModuleImportCallbackPtr callback) {
   PreModuleImportCallback = callback;
 }
 
+void ASTContext::PreModuleImportHook(StringRef ModuleName,
+                                     ModuleImportKind Kind) const {
+  if (PreModuleImportCallback)
+    PreModuleImportCallback(ModuleName, Kind);
+}
+
 llvm::BumpPtrAllocator &ASTContext::getAllocator(AllocationArena arena) const {
   switch (arena) {
   case AllocationArena::Permanent:
@@ -2475,8 +2481,7 @@ ASTContext::getModule(ImportPath::Module ModulePath, bool AllowMemoryCached) {
       return M;
 
   auto moduleID = ModulePath[0];
-  if (PreModuleImportCallback)
-    PreModuleImportCallback(moduleID.Item.str(), false /*=IsOverlay*/);
+  PreModuleImportHook(moduleID.Item.str(), ModuleImportKind::Module);
   for (auto &importer : getImpl().ModuleLoaders) {
     if (ModuleDecl *M = importer->loadModule(moduleID.Loc, ModulePath,
                                              AllowMemoryCached)) {
@@ -2509,7 +2514,7 @@ ModuleDecl *ASTContext::getOverlayModule(const FileUnit *FU) {
     SmallString<16> path;
     ModPath.getString(path);
     if (!path.empty())
-      PreModuleImportCallback(path.str(), /*IsOverlay=*/true);
+      PreModuleImportCallback(path.str(), ModuleImportKind::Overlay);
   }
   for (auto &importer : getImpl().ModuleLoaders) {
     if (importer.get() == getClangModuleLoader())

lib/ClangImporter/ClangImporter.cpp

@@ -1539,6 +1539,10 @@ bool ClangImporter::Implementation::importHeader(
     std::unique_ptr<llvm::MemoryBuffer> sourceBuffer,
     bool implicitImport) {
 
+  // Progress update for the debugger.
+  SwiftContext.PreModuleImportHook(
+      headerName, ASTContext::ModuleImportKind::BridgingHeader);
+
   // Don't even try to load the bridging header if the Clang AST is in a bad
   // state. It could cause a crash.
   auto &clangDiags = getClangASTContext().getDiagnostics();