Add an external module dependency test

artemcm · artemcm · commit b85f547b138e · 2020-07-27T09:24:35.000-07:00
diff --git a/include/swift/AST/ModuleDependencies.h b/include/swift/AST/ModuleDependencies.h
@@ -230,6 +230,16 @@ class ModuleDependencies {
           fileDependencies));
   }
 
+  /// Describe an external dependency swift module.
+  static ModuleDependencies forExternalSwiftModuleStub(
+      const std::string &compiledModulePath,
+      const std::string &moduleDocPath,
+      const std::string &sourceInfoPath) {
+    return ModuleDependencies(
+        std::make_unique<ExternalSwiftModuleDependencyStorage>(
+          compiledModulePath, moduleDocPath, sourceInfoPath));
+  }
+
   /// Retrieve the path to the compiled module.
   const std::string getCompiledModulePath() const {
     return storage->compiledModulePath;
diff --git a/include/swift/Frontend/ModuleInterfaceLoader.h b/include/swift/Frontend/ModuleInterfaceLoader.h
@@ -207,45 +207,6 @@ class ExplicitModuleMapParser {
   llvm::StringSaver Saver;
 };
 
-///// A ModuleLoader that loads external dependency module stubs specified in
-///// -external-dependency-module-map-file
-///// This loader is used only in dependency scanning to inform the scanner that a set of modules
-///// constitute external dependencies that are not visible to the scanner but will nevertheless be
-///// taken care of by the scanner's clients. This "loader" will not attempt to load any module files.
-//class ExternalSwiftModuleStubLoader: public SerializedModuleLoaderBase {
-//  explicit ExternalSwiftModuleStubLoader(ASTContext &ctx, DependencyTracker *tracker,
-//                                         ModuleLoadingMode loadMode,
-//                                         bool IgnoreSwiftSourceInfoFile);
-//  std::error_code findModuleFilesInDirectory(
-//    AccessPathElem ModuleID,
-//    const SerializedModuleBaseName &BaseName,
-//    SmallVectorImpl<char> *ModuleInterfacePath,
-//    std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer,
-//    std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer,
-//    std::unique_ptr<llvm::MemoryBuffer> *ModuleSourceInfoBuffer) override;
-//
-//  bool canImportModule(Located<Identifier> mID) override;
-//
-//  bool isCached(StringRef DepPath) override { return false; };
-//
-//  struct Implementation;
-//  Implementation &Impl;
-//public:
-//  static std::unique_ptr<ExternalSwiftModuleStubLoader>
-//  create(ASTContext &ctx,
-//         DependencyTracker *tracker, ModuleLoadingMode loadMode,
-//         StringRef ExternalDependencyModuleMap,
-//         bool IgnoreSwiftSourceInfoFile);
-//
-//  /// Append visible module names to \p names. Note that names are possibly
-//  /// duplicated, and not guaranteed to be ordered in any way.
-//  void collectVisibleTopLevelModuleNames(
-//      SmallVectorImpl<Identifier> &names) const override;
-//
-//  /// Actual record of the decoded stub.
-//  Optional<ModuleDependencies> dependencies;
-//};
-
 struct ModuleInterfaceLoaderOptions {
   bool remarkOnRebuildFromInterface = false;
   bool disableInterfaceLock = false;
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp
@@ -98,13 +98,13 @@ class ModuleDependencyScanner : public SerializedModuleLoaderBase {
 /// set of modules constitute external dependencies that are not visible to the
 /// scanner but will nevertheless be provided by the scanner's clients.
 /// This "loader" will not attempt to load any module files.
-class ExternalSwiftModuleStubLoader : public ModuleDependencyScanner {
+class ExternalSwiftModuleStubScanner : public ModuleDependencyScanner {
   /// Scan the given external module map
   void parseExternalModuleMap(StringRef fileName);
   llvm::StringMap<ExplicitModuleInfo> ExternalDependencyModuleMap;
 
 public:
-  ExternalSwiftModuleStubLoader(ASTContext &ctx, ModuleLoadingMode LoadMode,
+  ExternalSwiftModuleStubScanner(ASTContext &ctx, ModuleLoadingMode LoadMode,
                                 Identifier moduleName,
                                 StringRef ExternalDependencyModuleMap,
                                 InterfaceSubContextDelegate &astDelegate)
@@ -141,14 +141,14 @@ class ExternalSwiftModuleStubLoader : public ModuleDependencyScanner {
   }
 
 public:
-  static std::unique_ptr<ExternalSwiftModuleStubLoader>
+  static std::unique_ptr<ExternalSwiftModuleStubScanner>
   create(ASTContext &ctx, DependencyTracker *tracker,
          ModuleLoadingMode loadMode, StringRef ExternalDependencyModuleMap,
          bool IgnoreSwiftSourceInfoFile);
 };
 } // namespace
 
-void ExternalSwiftModuleStubLoader::parseExternalModuleMap(StringRef fileName) {
+void ExternalSwiftModuleStubScanner::parseExternalModuleMap(StringRef fileName) {
   ExplicitModuleMapParser parser(Ctx);
   auto result =
       parser.parseSwiftExplicitModuleMap(fileName, ExternalDependencyModuleMap);
@@ -229,6 +229,15 @@ Optional<ModuleDependencies> SerializedModuleLoaderBase::getModuleDependencies(
           cache.findDependencies(moduleName, ModuleDependenciesKind::SwiftExternal))
     return found;
 
+  auto moduleId = Ctx.getIdentifier(moduleName);
+  // Instantiate dependency scanning "loaders".
+  SmallVector<std::unique_ptr<ModuleDependencyScanner>, 2> scanners;
+  scanners.push_back(std::make_unique<ModuleDependencyScanner>(
+      Ctx, LoadMode, moduleId, delegate));
+  scanners.push_back(std::make_unique<ExternalSwiftModuleStubScanner>(
+      Ctx, LoadMode, moduleId, Ctx.SearchPathOpts.ExternalDependencyModuleMap,
+      delegate));
+
   // Check whether there is a module with this name that we can import.
   for (auto &scanner : scanners) {
     if (scanner->canImportModule({moduleId, SourceLoc()})) {
diff --git a/test/ScanDependencies/Inputs/ModuleDependencyGraph.swift b/test/ScanDependencies/Inputs/ModuleDependencyGraph.swift
@@ -13,19 +13,22 @@ import Foundation
 
 enum ModuleDependencyId: Hashable {
   case swift(String)
+  case swiftExternal(String)
   case clang(String)
 
   var moduleName: String {
     switch self {
-      case .swift(let name): return name
-      case .clang(let name): return name
+    case .swift(let name): return name
+    case .swiftExternal(let name): return name
+    case .clang(let name): return name
     }
   }
 }
 
 extension ModuleDependencyId: Codable {
   enum CodingKeys: CodingKey {
     case swift
+    case swiftExternal
     case clang
   }
 
@@ -35,8 +38,13 @@ extension ModuleDependencyId: Codable {
       let moduleName =  try container.decode(String.self, forKey: .swift)
       self = .swift(moduleName)
     } catch {
-      let moduleName =  try container.decode(String.self, forKey: .clang)
-      self = .clang(moduleName)
+      do {
+        let moduleName =  try container.decode(String.self, forKey: .swiftExternal)
+        self = .swiftExternal(moduleName)
+      } catch {
+        let moduleName =  try container.decode(String.self, forKey: .clang)
+        self = .clang(moduleName)
+      }
     }
   }
 
@@ -45,6 +53,8 @@ extension ModuleDependencyId: Codable {
     switch self {
       case .swift(let moduleName):
         try container.encode(moduleName, forKey: .swift)
+      case .swiftExternal(let moduleName):
+        try container.encode(moduleName, forKey: .swift)
       case .clang(let moduleName):
         try container.encode(moduleName, forKey: .clang)
     }
@@ -82,6 +92,15 @@ struct SwiftModuleDetails: Codable {
   var extraPcmArgs: [String]?
 }
 
+/// Details specific to Swift external modules.
+struct SwiftExternalModuleDetails: Codable {
+  /// The path to the .swiftModuleDoc file.
+  var moduleDocPath: String?
+
+  /// The path to the .swiftSourceInfo file.
+  var moduleSourceInfoPath: String?
+}
+
 /// Details specific to Clang modules.
 struct ClangModuleDetails: Codable {
   /// The path to the module map used to build this module.
@@ -100,10 +119,10 @@ struct ModuleDependencies: Codable {
   var modulePath: String
 
   /// The source files used to build this module.
-  var sourceFiles: [String] = []
+  var sourceFiles: [String]? = []
 
   /// The set of direct module dependencies of this module.
-  var directDependencies: [ModuleDependencyId] = []
+  var directDependencies: [ModuleDependencyId]? = []
 
   /// Specific details of a particular kind of module.
   var details: Details
@@ -114,6 +133,10 @@ struct ModuleDependencies: Codable {
     /// a bridging header.
     case swift(SwiftModuleDetails)
 
+    /// Swift external modules carry additional details that specify their
+    /// module doc path and source info paths.
+    case swiftExternal(SwiftExternalModuleDetails)
+
     /// Clang modules are built from a module map file.
     case clang(ClangModuleDetails)
   }
@@ -122,6 +145,7 @@ struct ModuleDependencies: Codable {
 extension ModuleDependencies.Details: Codable {
   enum CodingKeys: CodingKey {
     case swift
+    case swiftExternal
     case clang
   }
 
@@ -131,8 +155,13 @@ extension ModuleDependencies.Details: Codable {
       let details = try container.decode(SwiftModuleDetails.self, forKey: .swift)
       self = .swift(details)
     } catch {
-      let details = try container.decode(ClangModuleDetails.self, forKey: .clang)
-      self = .clang(details)
+      do {
+        let details = try container.decode(SwiftExternalModuleDetails.self, forKey: .swiftExternal)
+        self = .swiftExternal(details)
+      } catch {
+        let details = try container.decode(ClangModuleDetails.self, forKey: .clang)
+        self = .clang(details)
+      }
     }
   }
 
@@ -141,6 +170,8 @@ extension ModuleDependencies.Details: Codable {
     switch self {
       case .swift(let details):
         try container.encode(details, forKey: .swift)
+      case .swiftExternal(let details):
+        try container.encode(details, forKey: .swiftExternal)
       case .clang(let details):
         try container.encode(details, forKey: .clang)
     }
diff --git a/test/ScanDependencies/module_deps_external.swift b/test/ScanDependencies/module_deps_external.swift
@@ -0,0 +1,94 @@
+// RUN: %empty-directory(%t)
+// RUN: mkdir -p %t/clang-module-cache
+// RUN: mkdir -p %t/inputs
+
+// RUN: echo "[{" > %/t/inputs/map.json
+// RUN: echo "\"moduleName\": \"SomeExternalModule\"," >> %/t/inputs/map.json
+// RUN: echo "\"modulePath\": \"%/t/inputs/SomeExternalModule.swiftmodule\"," >> %/t/inputs/map.json
+// RUN: echo "\"docPath\": \"%/t/inputs/SomeExternalModule.swiftdoc\"," >> %/t/inputs/map.json
+// RUN: echo "\"sourceInfoPath\": \"%/t/inputs/SomeExternalModule.swiftsourceinfo\"" >> %/t/inputs/map.json
+// RUN: echo "}]" >> %/t/inputs/map.json
+
+// RUN: %target-swift-frontend -scan-dependencies -module-cache-path %t/clang-module-cache %s -external-dependency-module-map-file %t/inputs/map.json -o %t/deps.json -I %S/Inputs/CHeaders -I %S/Inputs/Swift -emit-dependencies -emit-dependencies-path %t/deps.d -import-objc-header %S/Inputs/CHeaders/Bridging.h -swift-version 4 -disable-implicit-swift-modules -Xcc -Xclang -Xcc -fno-implicit-modules
+
+// Check the contents of the JSON output
+// RUN: %FileCheck %s < %t/deps.json
+
+// Check the make-style dependencies file
+// RUN: %FileCheck %s -check-prefix CHECK-MAKE-DEPS < %t/deps.d
+
+// Check that the JSON parses correctly into the canonical Swift data
+// structures.
+
+// RUN: mkdir -p %t/PrintGraph
+// RUN: cp %S/Inputs/PrintGraph.swift %t/main.swift
+// RUN: %target-build-swift %S/Inputs/ModuleDependencyGraph.swift %t/main.swift -o %t/main
+// RUN: %target-codesign %t/main
+// RUN: %target-run %t/main %t/deps.json
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+import SomeExternalModule
+
+// CHECK: "mainModuleName": "deps"
+
+/// --------Main module
+// CHECK-LABEL: "modulePath": "deps.swiftmodule",
+// CHECK-NEXT: sourceFiles
+// CHECK-NEXT: module_deps_external.swift
+
+// CHECK: directDependencies
+// CHECK-NEXT: {
+// CHECK-NEXT: "swiftExternal": "SomeExternalModule"
+// CHECK-NEXT: }
+// CHECK-NEXT: {
+// CHECK-NEXT: "swift": "Swift"
+// CHECK-NEXT: }
+// CHECK-NEXT: {
+// CHECK-NEXT: "swift": "SwiftOnoneSupport"
+// CHECK-NEXT: }
+// CHECK-NEXT: {
+// CHECK-NEXT: "swift": "F"
+// CHECK-NEXT: }
+// CHECK-NEXT: ],
+
+// CHECK:      "extraPcmArgs": [
+// CHECK-NEXT:    "-Xcc",
+// CHECK-NEXT:    "-target",
+// CHECK-NEXT:    "-Xcc",
+// CHECK:         "-fapinotes-swift-version=4"
+
+// CHECK: "bridgingHeader":
+// CHECK-NEXT: "path":
+// CHECK-SAME: Bridging.h
+
+// CHECK-NEXT: "sourceFiles":
+// CHECK-NEXT: Bridging.h
+// CHECK-NEXT: BridgingOther.h
+
+// CHECK: "moduleDependencies": [
+// CHECK-NEXT: "F"
+// CHECK-NEXT: ]
+
+/// --------Swift external module SomeExternalModule
+// CHECK-LABEL: "modulePath": "BUILD_DIR/test-macosx-x86_64/ScanDependencies/Output/module_deps_external.swift.tmp/inputs/SomeExternalModule.swiftmodule",
+// CHECK-NEXT: "details": {
+// CHECK-NEXT: "swiftExternal": {
+// CHECK-NEXT: "moduleDocPath": "BUILD_DIR/test-macosx-x86_64/ScanDependencies/Output/module_deps_external.swift.tmp/inputs/SomeExternalModule.swiftdoc",
+// CHECK-NEXT: "moduleSourceInfoPath": "BUILD_DIR/test-macosx-x86_64/ScanDependencies/Output/module_deps_external.swift.tmp/inputs/SomeExternalModule.swiftsourceinfo",
+
+/// --------Swift module Swift
+// CHECK-LABEL: "modulePath": "Swift.swiftmodule",
+
+// CHECK: directDependencies
+// CHECK-NEXT: {
+// CHECK-NEXT: "clang": "SwiftShims"
+
+/// --------Clang module SwiftShims
+// CHECK-LABEL: "modulePath": "SwiftShims.pcm",
+
+// Check make-style dependencies
+// CHECK-MAKE-DEPS: module_deps_external.swift
+// CHECK-MAKE-DEPS-SAME: Bridging.h
+// CHECK-MAKE-DEPS-SAME: BridgingOther.h
+// CHECK-MAKE-DEPS-SAME: module.modulemap
