Move DWARFImporterDelegate into ClangImporter and remove DWARFImporter.

Author: adrian-prantl

include/swift/Basic/LangOptions.h

@@ -115,9 +115,6 @@ namespace swift {
     /// Only used by lldb-moduleimport-test.
     bool EnableMemoryBufferImporter = false;
 
-    /// Enable the DWARFImporter. Only used by lldb-moduleimport-test.
-    bool EnableDWARFImporter = false;
-    
     /// Allows using identifiers with a leading dollar.
     bool EnableDollarIdentifiers = false;
 

include/swift/ClangImporter/ClangImporter.h

@@ -60,6 +60,24 @@ class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
 
+/// This interface is implemented by LLDB to serve as a fallback when Clang
+/// modules can't be imported from source in the debugger.
+///
+/// During compile time, ClangImporter-imported Clang modules are compiled with
+/// -gmodules, which emits a DWARF rendition of all types defined in the module
+/// into the .pcm file. On Darwin, these types can be collected by
+/// dsymutil. This delegate allows DWARFImporter to ask LLDB to look up a Clang
+/// type by name, synthesize a Clang AST from it. DWARFImporter then hands this
+/// Clang AST to ClangImporter to import the type into Swift.
+class DWARFImporterDelegate {
+public:
+  virtual ~DWARFImporterDelegate() {}
+  /// Perform a qualified lookup of a Clang type with this name.
+  /// \param kind  Only return results with this type kind.
+  virtual void lookupValue(StringRef name, llvm::Optional<ClangTypeKind> kind,
+                           SmallVectorImpl<clang::Decl *> &results) {}
+};
+
 /// Class that imports Clang modules into Swift, mapping directly
 /// from Clang ASTs over to Swift ASTs.
 class ClangImporter final : public ClangModuleLoader {
@@ -73,7 +91,13 @@ class ClangImporter final : public ClangModuleLoader {
   Implementation &Impl;
 
   ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
-                DependencyTracker *tracker);
+                DependencyTracker *tracker,
+                std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate);
+
+  ModuleDecl *loadModuleClang(SourceLoc importLoc,
+                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
+  ModuleDecl *loadModuleDWARF(SourceLoc importLoc,
+                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
 
 public:
   /// Create a new Clang importer that can import a suitable Clang
@@ -89,13 +113,15 @@ class ClangImporter final : public ClangModuleLoader {
   ///
   /// \param tracker The object tracking files this compilation depends on.
   ///
+  /// \param dwarfImporterDelegate A helper object that can synthesize
+  /// Clang Decls from debug info. Used by LLDB.
+  ///
   /// \returns a new Clang module importer, or null (with a diagnostic) if
   /// an error occurred.
   static std::unique_ptr<ClangImporter>
-  create(ASTContext &ctx,
-         const ClangImporterOptions &importerOpts,
-         std::string swiftPCHHash = "",
-         DependencyTracker *tracker = nullptr);
+  create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
+         std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
+         std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate = {});
 
   ClangImporter(const ClangImporter &) = delete;
   ClangImporter(ClangImporter &&) = delete;

include/swift/DWARFImporter/DWARFImporter.h

@@ -1094,11 +1094,6 @@ GenericTypeDecl *ASTBuilder::findForeignTypeDecl(StringRef name,
     break;
   case ForeignModuleKind::Imported:
     importer->lookupTypeDecl(name, *lookupKind, found);
-
-    // Try the DWARFImporter if it exists.
-    if (!consumer.Result)
-      if (auto *dwarf_importer = Ctx.getDWARFModuleLoader())
-        dwarf_importer->lookupTypeDecl(name, *lookupKind, found);
   }
 
   return consumer.Result;

lib/AST/ASTDemangler.cpp

@@ -20,7 +20,6 @@ add_subdirectory(Basic)
 add_subdirectory(ClangImporter)
 add_subdirectory(Demangling)
 add_subdirectory(Driver)
-add_subdirectory(DWARFImporter)
 add_subdirectory(Frontend)
 add_subdirectory(FrontendTool)
 add_subdirectory(Index)

lib/CMakeLists.txt

@@ -9,6 +9,7 @@ add_swift_host_library(swiftClangImporter STATIC
   ClangAdapter.cpp
   ClangDiagnosticConsumer.cpp
   ClangImporter.cpp
+  DWARFImporter.cpp
   IAMInference.cpp
   ImportDecl.cpp
   ImportEnumInfo.cpp

lib/ClangImporter/CMakeLists.txt

@@ -386,12 +386,12 @@ bool ClangImporter::Implementation::shouldIgnoreBridgeHeaderTopLevelDecl(
   return false;
 }
 
-ClangImporter::ClangImporter(ASTContext &ctx,
-                             const ClangImporterOptions &clangImporterOpts,
-                             DependencyTracker *tracker)
-  : ClangModuleLoader(tracker),
-    Impl(*new Implementation(ctx, clangImporterOpts))
-{
+ClangImporter::ClangImporter(
+    ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
+    DependencyTracker *tracker,
+    std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate)
+    : ClangModuleLoader(tracker),
+      Impl(*new Implementation(ctx, clangImporterOpts, dwarfImporterDelegate)) {
 }
 
 ClangImporter::~ClangImporter() {
@@ -909,13 +909,12 @@ ClangImporter::getOrCreatePCH(const ClangImporterOptions &ImporterOptions,
   return PCHFilename.getValue();
 }
 
-std::unique_ptr<ClangImporter>
-ClangImporter::create(ASTContext &ctx,
-                      const ClangImporterOptions &importerOpts,
-                      std::string swiftPCHHash,
-                      DependencyTracker *tracker) {
+std::unique_ptr<ClangImporter> ClangImporter::create(
+    ASTContext &ctx, const ClangImporterOptions &importerOpts,
+    std::string swiftPCHHash, DependencyTracker *tracker,
+    std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate) {
   std::unique_ptr<ClangImporter> importer{
-    new ClangImporter(ctx, importerOpts, tracker)
+    new ClangImporter(ctx, importerOpts, tracker, dwarfImporterDelegate)
   };
 
   std::vector<std::string> invocationArgStrs;
@@ -1575,7 +1574,7 @@ bool ClangImporter::canImportModule(std::pair<Identifier, SourceLoc> moduleID) {
   return clangModule->isAvailable(ctx.getLangOpts(), getTargetInfo(), r, mh, m);
 }
 
-ModuleDecl *ClangImporter::loadModule(
+ModuleDecl *ClangImporter::loadModuleClang(
     SourceLoc importLoc,
     ArrayRef<std::pair<Identifier, SourceLoc>> path) {
   auto &clangContext = Impl.getClangASTContext();
@@ -1668,6 +1667,15 @@ ModuleDecl *ClangImporter::loadModule(
   return Impl.finishLoadingClangModule(clangModule, /*preferOverlay=*/false);
 }
 
+ModuleDecl *ClangImporter::loadModule(
+    SourceLoc importLoc,
+    ArrayRef<std::pair<Identifier, SourceLoc>> path) {
+  ModuleDecl *MD = loadModuleClang(importLoc, path);
+  if (!MD)
+    MD = loadModuleDWARF(importLoc, path);
+  return MD;
+}
+
 ModuleDecl *ClangImporter::Implementation::finishLoadingClangModule(
     const clang::Module *clangModule,
     bool findOverlay) {
@@ -1834,8 +1842,9 @@ bool PlatformAvailability::treatDeprecatedAsUnavailable(
   llvm_unreachable("Unexpected platform");
 }
 
-ClangImporter::Implementation::Implementation(ASTContext &ctx,
-                                              const ClangImporterOptions &opts)
+ClangImporter::Implementation::Implementation(
+    ASTContext &ctx, const ClangImporterOptions &opts,
+    std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate)
     : SwiftContext(ctx),
       ImportForwardDeclarations(opts.ImportForwardDeclarations),
       InferImportAsMember(opts.InferImportAsMember),
@@ -1845,8 +1854,8 @@ ClangImporter::Implementation::Implementation(ASTContext &ctx,
       IsReadingBridgingPCH(false),
       CurrentVersion(ImportNameVersion::fromOptions(ctx.LangOpts)),
       BridgingHeaderLookupTable(new SwiftLookupTable(nullptr)),
-      platformAvailability(ctx.LangOpts),
-      nameImporter() {}
+      platformAvailability(ctx.LangOpts), nameImporter(),
+      DWARFImporter(dwarfImporterDelegate) {}
 
 ClangImporter::Implementation::~Implementation() {
 #ifndef NDEBUG
@@ -2489,10 +2498,25 @@ bool ClangImporter::lookupDeclsFromHeader(StringRef Filename,
 }
 
 void ClangImporter::lookupValue(DeclName name, VisibleDeclConsumer &consumer){
+  struct ForwardingConsumer : VisibleDeclConsumer {
+    VisibleDeclConsumer &consumer;
+    bool foundAny = false;
+
+    ForwardingConsumer(ForwardingConsumer &forwardee) : consumer(forwardee) {}
+
+    void foundDecl(ValueDecl *decl, DeclVisibilityKind reason,
+                   DynamicLookupInfo dynamicLookupInfo = {}) override {
+      FoundAny = true;
+      consumer.foundDecl(decl, reason, dynamicLookupInfo);
+    }
+  } forwarder(consumer);
+
   Impl.forEachLookupTable([&](SwiftLookupTable &table) -> bool {
-      Impl.lookupValue(table, name, consumer);
+      Impl.lookupValue(table, name, forwarder);
       return false;
     });
+  if (!forwarder.foundAny)
+    Impl.lookupValueDWARF(name, consumer);
 }
 
 void ClangImporter::lookupTypeDecl(

lib/ClangImporter/ClangImporter.cpp

@@ -318,11 +318,11 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
     public LazyConformanceLoader
 {
   friend class ClangImporter;
-  friend class DWARFImporter;
   using Version = importer::ImportNameVersion;
 
 public:
-  Implementation(ASTContext &ctx, const ClangImporterOptions &opts);
+  Implementation(ASTContext &ctx, const ClangImporterOptions &opts,
+                 std::unique_ptr<DWARFImporterDelegate> dwarfImporterDelegate);
   ~Implementation();
 
   /// Swift AST context.
@@ -603,6 +603,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void addBridgeHeaderTopLevelDecls(clang::Decl *D);
   bool shouldIgnoreBridgeHeaderTopLevelDecl(clang::Decl *D);
 
+private:
+  /// The DWARF importer delegate, if installed.
+  std::unique_ptr<DWARFImporterDelegate> DWARFImporter;
+  
 public:
   void recordImplicitUnwrapForDecl(Decl *decl, bool isIUO) {
 #if !defined(NDEBUG)
@@ -1308,6 +1312,10 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
   void lookupValue(SwiftLookupTable &table, DeclName name,
                    VisibleDeclConsumer &consumer);
 
+  /// Look for namespace-scope values with the given name using the
+  /// DWARFImporterDelegate.
+  void lookupValueDWARF(DeclName name, VisibleDeclConsumer &consumer);
+
   /// Look for namespace-scope values in the given Swift lookup table.
   void lookupVisibleDecls(SwiftLookupTable &table,
                           VisibleDeclConsumer &consumer);