Merge remote-tracking branch 'origin/master' into master-rebranch

Author: swift-ci

include/swift/ClangImporter/ClangImporter.h

@@ -108,8 +108,6 @@ class ClangImporter final : public ClangModuleLoader {
                 DependencyTracker *tracker,
                 DWARFImporterDelegate *dwarfImporterDelegate);
 
-  ModuleDecl *loadModuleClang(SourceLoc importLoc,
-                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
 public:
   /// Create a new Clang importer that can import a suitable Clang
   /// module into the given ASTContext.
@@ -141,6 +139,9 @@ class ClangImporter final : public ClangModuleLoader {
 
   ~ClangImporter();
 
+  /// Only to be used by lldb-moduleimport-test.
+  void setDWARFImporterDelegate(DWARFImporterDelegate &delegate);
+
   /// Create a new clang::DependencyCollector customized to
   /// ClangImporter's specific uses.
   static std::shared_ptr<clang::DependencyCollector>

lib/ClangImporter/ClangImporter.cpp

@@ -1573,11 +1573,10 @@ bool ClangImporter::canImportModule(std::pair<Identifier, SourceLoc> moduleID) {
   return clangModule->isAvailable(ctx.getLangOpts(), getTargetInfo(), r, mh, m);
 }
 
-ModuleDecl *ClangImporter::loadModuleClang(
-    SourceLoc importLoc,
-    ArrayRef<std::pair<Identifier, SourceLoc>> path) {
-  auto &clangContext = Impl.getClangASTContext();
-  auto &clangHeaderSearch = Impl.getClangPreprocessor().getHeaderSearchInfo();
+ModuleDecl *ClangImporter::Implementation::loadModuleClang(
+    SourceLoc importLoc, ArrayRef<std::pair<Identifier, SourceLoc>> path) {
+  auto &clangContext = getClangASTContext();
+  auto &clangHeaderSearch = getClangPreprocessor().getHeaderSearchInfo();
 
   // Look up the top-level module first, to see if it exists at all.
   clang::Module *clangModule = clangHeaderSearch.lookupModule(
@@ -1588,47 +1587,47 @@ ModuleDecl *ClangImporter::loadModuleClang(
 
   // Convert the Swift import path over to a Clang import path.
   SmallVector<std::pair<clang::IdentifierInfo *, clang::SourceLocation>, 4>
-    clangPath;
+      clangPath;
   for (auto component : path) {
-    clangPath.push_back({ &clangContext.Idents.get(component.first.str()),
-                          Impl.exportSourceLoc(component.second) } );
+    clangPath.push_back({&clangContext.Idents.get(component.first.str()),
+                         exportSourceLoc(component.second)});
   }
 
-  auto &rawDiagClient = Impl.Instance->getDiagnosticClient();
+  auto &rawDiagClient = Instance->getDiagnosticClient();
   auto &diagClient = static_cast<ClangDiagnosticConsumer &>(rawDiagClient);
 
   auto loadModule = [&](clang::ModuleIdPath path,
                         bool makeVisible) -> clang::ModuleLoadResult {
     clang::Module::NameVisibilityKind visibility =
-      makeVisible ? clang::Module::AllVisible : clang::Module::Hidden;
+        makeVisible ? clang::Module::AllVisible : clang::Module::Hidden;
 
-    auto importRAII = diagClient.handleImport(clangPath.front().first,
-                                              importLoc);
+    auto importRAII =
+        diagClient.handleImport(clangPath.front().first, importLoc);
 
     std::string preservedIndexStorePathOption;
-    auto &clangFEOpts = Impl.Instance->getFrontendOpts();
+    auto &clangFEOpts = Instance->getFrontendOpts();
     if (!clangFEOpts.IndexStorePath.empty()) {
       StringRef moduleName = path[0].first->getName();
       // Ignore the SwiftShims module for the index data.
-      if (moduleName == Impl.SwiftContext.SwiftShimsModuleName.str()) {
+      if (moduleName == SwiftContext.SwiftShimsModuleName.str()) {
         preservedIndexStorePathOption = clangFEOpts.IndexStorePath;
         clangFEOpts.IndexStorePath.clear();
       }
     }
 
-    clang::SourceLocation clangImportLoc = Impl.getNextIncludeLoc();
+    clang::SourceLocation clangImportLoc = getNextIncludeLoc();
 
     clang::ModuleLoadResult result =
-        Impl.Instance->loadModule(clangImportLoc, path, visibility,
-                                  /*IsInclusionDirective=*/false);
+        Instance->loadModule(clangImportLoc, path, visibility,
+                             /*IsInclusionDirective=*/false);
 
     if (!preservedIndexStorePathOption.empty()) {
       // Restore the -index-store-path option.
       clangFEOpts.IndexStorePath = preservedIndexStorePathOption;
     }
 
     if (result && makeVisible)
-      Impl.getClangPreprocessor().makeModuleVisible(result, clangImportLoc);
+      getClangPreprocessor().makeModuleVisible(result, clangImportLoc);
     return result;
   };
 
@@ -1663,13 +1662,13 @@ ModuleDecl *ClangImporter::loadModuleClang(
   if (!clangModule)
     return nullptr;
 
-  return Impl.finishLoadingClangModule(clangModule, /*preferOverlay=*/false);
+  return finishLoadingClangModule(clangModule, /*preferOverlay=*/false);
 }
 
 ModuleDecl *ClangImporter::loadModule(
     SourceLoc importLoc,
     ArrayRef<std::pair<Identifier, SourceLoc>> path) {
-  ModuleDecl *MD = loadModuleClang(importLoc, path);
+  ModuleDecl *MD = Impl.loadModuleClang(importLoc, path);
   if (!MD)
     MD = Impl.loadModuleDWARF(importLoc, path);
   return MD;

lib/ClangImporter/DWARFImporter.cpp

@@ -176,3 +176,12 @@ void ClangImporter::Implementation::lookupTypeDeclDWARF(
       receiver(importedType);
   }
 }
+
+void ClangImporter::setDWARFImporterDelegate(DWARFImporterDelegate &delegate) {
+  Impl.setDWARFImporterDelegate(delegate);
+}
+
+void ClangImporter::Implementation::setDWARFImporterDelegate(
+    DWARFImporterDelegate &delegate) {
+  DWARFImporter = &delegate;
+}

lib/ClangImporter/ImporterImpl.h

@@ -606,14 +606,23 @@ class LLVM_LIBRARY_VISIBILITY ClangImporter::Implementation
 private:
   /// The DWARF importer delegate, if installed.
   DWARFImporterDelegate *DWARFImporter = nullptr;
+public:
+  /// Only used for testing.
+  void setDWARFImporterDelegate(DWARFImporterDelegate &delegate);
+
+private:
   /// The list of Clang modules found in the debug info.
   llvm::DenseMap<Identifier, LoadedFile *> DWARFModuleUnits;
-
 public:
-  /// "Import" a module from debug info. Because debug info types are read on
+  /// Load a module using the clang::CompilerInstance.
+  ModuleDecl *loadModuleClang(SourceLoc importLoc,
+                              ArrayRef<std::pair<Identifier, SourceLoc>> path);
+  
+  /// "Load" a module from debug info. Because debug info types are read on
   /// demand, this doesn't really do any work.
   ModuleDecl *loadModuleDWARF(SourceLoc importLoc,
                               ArrayRef<std::pair<Identifier, SourceLoc>> path);
+
 
   void recordImplicitUnwrapForDecl(ValueDecl *decl, bool isIUO) {
     if (!isIUO)

test/DWARFImporter/Inputs/module.modulemap

@@ -0,0 +1,4 @@
+module ObjCModule {
+  header "objc-header.h"
+  export *
+}

test/DWARFImporter/Inputs/objc-header.h

@@ -0,0 +1,7 @@
+struct Point {
+  int x, y;
+};
+
+@interface ObjCClass
+- (instancetype)init;
+@end

test/DWARFImporter/basic.swift

@@ -0,0 +1,32 @@
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+
+// RUN: %empty-directory(%t)
+
+// RUN: cp %S/Inputs/objc-header.h %S/Inputs/module.modulemap  %t
+// RUN: %target-build-swift -emit-executable %s -g -o %t/a.out \
+// RUN:   -module-name basic -emit-module -I%t
+//        -DOBJC -module-name basic
+// RUN: %lldb-moduleimport-test -verbose -dump-module %t/a.out | %FileCheck %s
+
+// RUN: rm %t/objc-header.h
+// RUN: %lldb-moduleimport-test -verbose -dump-module %t/a.out \
+// RUN:    | %FileCheck %s --check-prefix=FAIL
+
+// RUN: %lldb-moduleimport-test -verbose -dump-module %t/a.out \
+// RUN:    -dummy-dwarfimporter | %FileCheck %s --check-prefix=SWIFTONLY
+
+// CHECK: Importing basic... ok!
+// FAIL: Importing basic... ok!
+// SWIFTONLY: Importing basic... ok!
+import ObjCModule
+
+let pureSwift = Int32(42)
+// FAIL-NOT:  var_decl
+// CHECK:     var_decl "pureSwift" {{.*}} type='Int32'
+// SWIFTONLY: var_decl "pureSwift" {{.*}} type='Int32' 
+
+let point = Point(x: 1, y: 2)
+// CHECK:     var_decl "point" {{.*}} type='Point'
+// SWIFTONLY-NOT: var_decl "point"
+

tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp

@@ -225,6 +225,10 @@ int main(int argc, char **argv) {
       desc("The directory that holds the compiler resource files"),
       cat(Visible));
 
+  opt<bool> DummyDWARFImporter(
+      "dummy-dwarfimporter",
+      desc("Install a dummy DWARFImporterDelegate"), cat(Visible));
+
   ParseCommandLineOptions(argc, argv);
 
   // Unregister our options so they don't interfere with the command line
@@ -301,6 +305,13 @@ int main(int argc, char **argv) {
     return 1;
   }
 
+  swift::DWARFImporterDelegate dummyDWARFImporter;
+  if (DummyDWARFImporter) {
+    auto *ClangImporter = static_cast<swift::ClangImporter *>(
+        CI.getASTContext().getClangModuleLoader());
+    ClangImporter->setDWARFImporterDelegate(dummyDWARFImporter);
+  }
+
   for (auto &Module : Modules)
     if (!parseASTSection(*CI.getMemoryBufferSerializedModuleLoader(),
                          StringRef(Module.first, Module.second), modules)) {