Introduce a DWARFImporter delegate that can look up clang::Decls by name.

Traditionally a serialized binary Swift module (as used in debug info)
can only be imported if all of its Clang dependencies can be imported
*from source*.

- Swift's ClangImporter imports Clang modules by converting Clang AST
  types into Swift AST types.

- LLDB knows how to find Clang types in DWARF or other debug info and
  can synthesize a Clang AST from that information.

This patch introduces a DWARFImporter delegate that is implemented by
LLDB to connect these two components. With this, a Clang type can be
found (by name) in the debug info and handed over to ClangImporter to
create a Swift type from it.  This path has lower fidelity than
importing the Clang modules from source, since it is missing out on
Swiftication annotations and other metadata that is not serialized in
DWARF, but it's invaluable as a fallback mechanism for the debugger
when source code for the Clang modules isn't available or the modules
are otherwise not buildable.

rdar://problem/49233932

Author: adrian-prantl

include/swift/AST/ASTContext.h

@@ -639,8 +639,10 @@ class ASTContext final {
   /// \param isClang \c true if this module loader is responsible for loading
   ///                Clang modules, which are special-cased in some parts of the
   ///                compiler.
+  /// \param isDWARF \c true if this module loader can load Clang modules
+  ///                from DWARF.
   void addModuleLoader(std::unique_ptr<ModuleLoader> loader,
-                       bool isClang = false);
+                       bool isClang = false, bool isDWARF = false);
 
   /// Load extensions to the given nominal type from the external
   /// module loaders.
@@ -683,6 +685,12 @@ class ASTContext final {
   /// The loader is owned by the AST context.
   ClangModuleLoader *getClangModuleLoader() const;
 
+  /// Retrieve the DWARF module loader for this ASTContext.
+  ///
+  /// If there is no Clang module loader, returns a null pointer.
+  /// The loader is owned by the AST context.
+  ClangModuleLoader *getDWARFModuleLoader() const;
+  
   /// Asks every module loader to verify the ASTs it has loaded.
   ///
   /// Does nothing in non-asserts (NDEBUG) builds.

include/swift/AST/ClangModuleLoader.h

@@ -14,6 +14,7 @@
 #define SWIFT_AST_CLANG_MODULE_LOADER_H
 
 #include "swift/AST/ModuleLoader.h"
+#include "swift/Demangling/Demangle.h"
 
 namespace clang {
 class ASTContext;
@@ -25,6 +26,7 @@ class Sema;
 namespace swift {
 
 class DeclContext;
+class VisibleDeclConsumer;
 
 class ClangModuleLoader : public ModuleLoader {
 private:
@@ -58,6 +60,30 @@ class ClangModuleLoader : public ModuleLoader {
                                             const DeclContext *overlayDC,
                                             const DeclContext *importedDC) = 0;
 
+  /// Look for declarations associated with the given name.
+  ///
+  /// \param name The name we're searching for.
+  virtual void lookupValue(DeclName name, VisibleDeclConsumer &consumer) {}
+
+  /// Look up a type declaration by its Clang name.
+  ///
+  /// Note that this method does no filtering. If it finds the type in a loaded
+  /// module, it returns it. This is intended for use in reflection / debugging
+  /// contexts where access is not a problem.
+  virtual void lookupTypeDecl(StringRef clangName, Demangle::Node::Kind kind,
+                              llvm::function_ref<void(TypeDecl *)> receiver) {}
+
+  /// Look up type a declaration synthesized by the Clang importer itself, using
+  /// a "related entity kind" to determine which type it should be. For example,
+  /// this can be used to find the synthesized error struct for an
+  /// NS_ERROR_ENUM.
+  ///
+  /// Note that this method does no filtering. If it finds the type in a loaded
+  /// module, it returns it. This is intended for use in reflection / debugging
+  /// contexts where access is not a problem.
+  virtual void
+  lookupRelatedEntity(StringRef clangName, StringRef relatedEntityKind,
+                      llvm::function_ref<void(TypeDecl *)> receiver) {}
 };
 
 } // namespace swift

include/swift/AST/ModuleLoader.h

@@ -35,6 +35,7 @@ class ClangImporterOptions;
 class ClassDecl;
 class ModuleDecl;
 class NominalTypeDecl;
+class TypeDecl;
 
 enum class KnownProtocolKind : uint8_t;
 

include/swift/ClangImporter/ClangImporter.h

@@ -75,6 +75,7 @@ enum class ClangTypeKind {
 /// from Clang ASTs over to Swift ASTs.
 class ClangImporter final : public ClangModuleLoader {
   friend class ClangModuleUnit;
+  friend class DWARFImporter;
 
 public:
   class Implementation;
@@ -160,15 +161,15 @@ class ClangImporter final : public ClangModuleLoader {
   /// Look for declarations associated with the given name.
   ///
   /// \param name The name we're searching for.
-  void lookupValue(DeclName name, VisibleDeclConsumer &consumer);
+  void lookupValue(DeclName name, VisibleDeclConsumer &consumer) override;
 
   /// Look up a type declaration by its Clang name.
   ///
   /// Note that this method does no filtering. If it finds the type in a loaded
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
-  void lookupTypeDecl(StringRef clangName, ClangTypeKind kind,
-                      llvm::function_ref<void(TypeDecl*)> receiver);
+  void lookupTypeDecl(StringRef clangName, Demangle::Node::Kind kind,
+                      llvm::function_ref<void(TypeDecl*)> receiver) override;
 
   /// Look up type a declaration synthesized by the Clang importer itself, using
   /// a "related entity kind" to determine which type it should be. For example,
@@ -178,9 +179,9 @@ class ClangImporter final : public ClangModuleLoader {
   /// Note that this method does no filtering. If it finds the type in a loaded
   /// module, it returns it. This is intended for use in reflection / debugging
   /// contexts where access is not a problem.
-  void lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
-                           StringRef relatedEntityKind,
-                           llvm::function_ref<void(TypeDecl*)> receiver);
+  void
+  lookupRelatedEntity(StringRef clangName, StringRef relatedEntityKind,
+                      llvm::function_ref<void(TypeDecl *)> receiver) override;
 
   /// Look for textually included declarations from the bridging header.
   ///

include/swift/DWARFImporter/DWARFImporter.h

@@ -18,6 +18,8 @@
 #define SWIFT_DWARF_IMPORTER_H
 
 #include "swift/AST/ClangModuleLoader.h"
+#include "swift/AST/Module.h"
+#include "swift/Demangling/Demangle.h"
 
 namespace llvm {
 }
@@ -27,6 +29,25 @@ namespace clang {
 
 namespace swift {
 
+/// 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<Demangle::Node::Kind> kind,
+                           SmallVectorImpl<clang::Decl *> &results) {}
+};
+
 /// Class that imports Clang modules into Swift, mapping directly
 /// from Clang ASTs over to Swift ASTs.
 class DWARFImporter final : public ClangModuleLoader {
@@ -39,6 +60,7 @@ class DWARFImporter final : public ClangModuleLoader {
   Implementation &Impl;
 
   DWARFImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
+                std::unique_ptr<DWARFImporterDelegate> delegate,
                 DependencyTracker *tracker);
 
 public:
@@ -55,8 +77,8 @@ class DWARFImporter final : public ClangModuleLoader {
   /// \returns a new DWARF module importer, or null (with a diagnostic) if
   /// an error occurred.
   static std::unique_ptr<DWARFImporter>
-  create(ASTContext &ctx,
-         const ClangImporterOptions &importerOpts,
+  create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
+         std::unique_ptr<DWARFImporterDelegate> delegate = {},
          DependencyTracker *tracker = nullptr);
 
   DWARFImporter(const DWARFImporter &) = delete;
@@ -80,6 +102,17 @@ class DWARFImporter final : public ClangModuleLoader {
   ModuleDecl *
   loadModule(SourceLoc importLoc,
              ArrayRef<std::pair<Identifier, SourceLoc>> path) override;
+
+  ValueDecl *importDecl(clang::Decl *clangDecl);
+
+  void lookupValue(DeclName name, VisibleDeclConsumer &consumer) override {}
+  /// Behaves like \p ClangImporter::lookupValue.
+  void lookupValue(ModuleDecl::AccessPathTy accessPath, DeclName name,
+                   NLKind lookupKind, SmallVectorImpl<ValueDecl *> &results);
+  /// Perform a qualified lookup of a Clang type with this name and only return
+  /// results with the specified type kind.
+  void lookupTypeDecl(StringRef rawName, Demangle::Node::Kind kind,
+                      llvm::function_ref<void(TypeDecl *)> receiver) override;
   bool
   isInOverlayModuleForImportedModule(const DeclContext *overlayDC,
                                      const DeclContext *importedDC) override;

lib/AST/ASTContext.cpp

@@ -255,6 +255,9 @@ FOR_KNOWN_FOUNDATION_TYPES(CACHE_FOUNDATION_DECL)
   /// The module loader used to load Clang modules.
   ClangModuleLoader *TheClangModuleLoader = nullptr;
 
+  /// The module loader used to load Clang modules from DWARF.
+  ClangModuleLoader *TheDWARFModuleLoader = nullptr;
+
   /// Map from Swift declarations to raw comments.
   llvm::DenseMap<const Decl *, RawComment> RawComments;
 
@@ -1446,10 +1449,13 @@ void ASTContext::addSearchPath(StringRef searchPath, bool isFramework,
 }
 
 void ASTContext::addModuleLoader(std::unique_ptr<ModuleLoader> loader,
-                                 bool IsClang) {
-  if (IsClang && !getImpl().TheClangModuleLoader)
+                                 bool IsClang, bool IsDwarf) {
+  if (IsClang && !IsDwarf && !getImpl().TheClangModuleLoader)
     getImpl().TheClangModuleLoader =
         static_cast<ClangModuleLoader *>(loader.get());
+  if (IsClang && IsDwarf && !getImpl().TheDWARFModuleLoader)
+    getImpl().TheDWARFModuleLoader =
+        static_cast<ClangModuleLoader *>(loader.get());
 
   getImpl().ModuleLoaders.push_back(std::move(loader));
 }
@@ -1493,6 +1499,10 @@ ClangModuleLoader *ASTContext::getClangModuleLoader() const {
   return getImpl().TheClangModuleLoader;
 }
 
+ClangModuleLoader *ASTContext::getDWARFModuleLoader() const {
+  return getImpl().TheDWARFModuleLoader;
+}
+
 ModuleDecl *ASTContext::getLoadedModule(
     ArrayRef<std::pair<Identifier, SourceLoc>> ModulePath) const {
   assert(!ModulePath.empty());

lib/AST/ASTDemangler.cpp

@@ -22,14 +22,14 @@
 #include "swift/AST/ASTDemangler.h"
 
 #include "swift/AST/ASTContext.h"
+#include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/GenericSignature.h"
 #include "swift/AST/GenericSignatureBuilder.h"
 #include "swift/AST/Module.h"
 #include "swift/AST/NameLookup.h"
 #include "swift/AST/Type.h"
 #include "swift/AST/Types.h"
-#include "swift/ClangImporter/ClangImporter.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
 
@@ -1023,31 +1023,14 @@ ASTBuilder::findTypeDecl(DeclContext *dc,
   return result;
 }
 
-static Optional<ClangTypeKind>
-getClangTypeKindForNodeKind(Demangle::Node::Kind kind) {
-  switch (kind) {
-  case Demangle::Node::Kind::Protocol:
-    return ClangTypeKind::ObjCProtocol;
-  case Demangle::Node::Kind::Class:
-    return ClangTypeKind::ObjCClass;
-  case Demangle::Node::Kind::TypeAlias:
-    return ClangTypeKind::Typedef;
-  case Demangle::Node::Kind::Structure:
-  case Demangle::Node::Kind::Enum:
-    return ClangTypeKind::Tag;
-  default:
-    return None;
-  }
-}
-
-GenericTypeDecl *
-ASTBuilder::findForeignTypeDecl(StringRef name,
-                                StringRef relatedEntityKind,
-                                ForeignModuleKind foreignKind,
-                                Demangle::Node::Kind kind) {
+GenericTypeDecl *ASTBuilder::findForeignTypeDecl(StringRef name,
+                                                 StringRef relatedEntityKind,
+                                                 ForeignModuleKind foreignKind,
+                                                 Demangle::Node::Kind kind) {
   // Check to see if we have an importer loaded.
-  auto importer = static_cast<ClangImporter *>(Ctx.getClangModuleLoader());
-  if (!importer) return nullptr;
+  auto importer = Ctx.getClangModuleLoader();
+  if (!importer)
+    return nullptr;
 
   // Find the unique declaration that has the right kind.
   struct Consumer : VisibleDeclConsumer {
@@ -1059,8 +1042,10 @@ ASTBuilder::findForeignTypeDecl(StringRef name,
 
     void foundDecl(ValueDecl *decl, DeclVisibilityKind reason,
                    DynamicLookupInfo dynamicLookupInfo = {}) override {
-      if (HadError) return;
-      if (decl == Result) return;
+      if (HadError)
+        return;
+      if (decl == Result)
+        return;
       if (!Result) {
         Result = dyn_cast<GenericTypeDecl>(decl);
         HadError |= !Result;
@@ -1071,33 +1056,27 @@ ASTBuilder::findForeignTypeDecl(StringRef name,
     }
   } consumer(kind);
 
+  auto found = [&](TypeDecl *found) {
+    consumer.foundDecl(found, DeclVisibilityKind::VisibleAtTopLevel);
+  };
+
   switch (foreignKind) {
   case ForeignModuleKind::SynthesizedByImporter:
     if (!relatedEntityKind.empty()) {
-      Optional<ClangTypeKind> lookupKind = getClangTypeKindForNodeKind(kind);
-      if (!lookupKind)
-        return nullptr;
-      importer->lookupRelatedEntity(name, lookupKind.getValue(),
-                                    relatedEntityKind, [&](TypeDecl *found) {
-        consumer.foundDecl(found, DeclVisibilityKind::VisibleAtTopLevel);
-      });
+      importer->lookupRelatedEntity(name, relatedEntityKind, found);
       break;
     }
     importer->lookupValue(Ctx.getIdentifier(name), consumer);
-    if (consumer.Result) {
-      consumer.Result =
-          getAcceptableTypeDeclCandidate(consumer.Result,kind);
-    }
+    if (consumer.Result)
+      consumer.Result = getAcceptableTypeDeclCandidate(consumer.Result, kind);
     break;
-  case ForeignModuleKind::Imported: {
-    Optional<ClangTypeKind> lookupKind = getClangTypeKindForNodeKind(kind);
-    if (!lookupKind)
-      return nullptr;
-    importer->lookupTypeDecl(name, lookupKind.getValue(),
-                             [&](TypeDecl *found) {
-      consumer.foundDecl(found, DeclVisibilityKind::VisibleAtTopLevel);
-    });
-  }
+  case ForeignModuleKind::Imported:
+    importer->lookupTypeDecl(name, kind, found);
+
+    // Try the DWARFImporter if it exists.
+    if (!consumer.Result)
+      if (auto *dwarf_importer = Ctx.getDWARFModuleLoader())
+        dwarf_importer->lookupTypeDecl(name, kind, found);
   }
 
   return consumer.Result;