[Dependency Scanning] Specify dependency inputs of Swift module dependencies on the command line

Do this by computing a transitive closure on the computed dependency graph, relying on the fact that it is a DAG.
The used algorithm is:
```
for each v ∈ V {
    T(v) = { v }
}
for v ∈ V in reverse topological order {
    for each (v, w) ∈ E {
         T(v) = T(v) ∪ T(w)
    }
}
```

Author: artemcm

include/swift/AST/ModuleDependencies.h

@@ -150,7 +150,7 @@ class SwiftInterfaceModuleDependenciesStorage :
 
   /// The Swift frontend invocation arguments to build the Swift module from the
   /// interface.
-  const std::vector<std::string> buildCommandLine;
+  std::vector<std::string> buildCommandLine;
 
   /// The hash value that will be used for the generated module
   const std::string contextHash;
@@ -186,6 +186,10 @@ class SwiftInterfaceModuleDependenciesStorage :
   static bool classof(const ModuleDependencyInfoStorageBase *base) {
     return base->dependencyKind == ModuleDependencyKind::SwiftInterface;
   }
+
+  void updateCommandLine(const std::vector<std::string> &newCommandLine) {
+    buildCommandLine = newCommandLine;
+  }
 };
 
 /// Describes the dependencies of a Swift module
@@ -433,6 +437,11 @@ class ModuleDependencyInfo {
     storage->resolvedModuleDependencies.assign(dependencyIDs.begin(), dependencyIDs.end());
   }
 
+  void updateCommandLine(const std::vector<std::string> &newCommandLine) {
+    assert(isSwiftInterfaceModule() && "Can only update command line on Swift interface dependency");
+    cast<SwiftInterfaceModuleDependenciesStorage>(storage.get())->updateCommandLine(newCommandLine);
+  }
+
   bool isResolved() const {
     return storage->resolved;
   }
@@ -752,4 +761,17 @@ class ModuleDependenciesCache {
 
 } // namespace swift
 
+namespace std {
+template <>
+struct hash<swift::ModuleDependencyID> {
+  using UnderlyingKindType = std::underlying_type<swift::ModuleDependencyKind>::type;
+  std::size_t operator()(const swift::ModuleDependencyID &id) const {
+    auto underlyingKindValue = static_cast<UnderlyingKindType>(id.second);
+
+    return (hash<string>()(id.first) ^
+            (hash<UnderlyingKindType>()(underlyingKindValue)));
+  }
+};
+} // namespace std
+
 #endif /* SWIFT_AST_MODULE_DEPENDENCIES_H */

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -129,7 +129,8 @@ class SearchPathOptions;
 class CompilerInvocation;
 
 /// A ModuleLoader that loads explicitly built Swift modules specified via
-/// -swift-module-file or modules found in
+/// -swift-module-file or modules found in a provided
+/// -explicit-swift-module-map-file JSON input.
 class ExplicitSwiftModuleLoader: public SerializedModuleLoaderBase {
   explicit ExplicitSwiftModuleLoader(ASTContext &ctx, DependencyTracker *tracker,
                                      ModuleLoadingMode loadMode,

lib/DependencyScan/ModuleDependencyCacheSerialization.cpp

@@ -656,19 +656,6 @@ struct llvm::DenseMapInfo<ModuleIdentifierArrayKind> {
   }
 };
 
-namespace std {
-template <>
-struct hash<ModuleDependencyID> {
-  using UnderlyingKindType = std::underlying_type<ModuleDependencyKind>::type;
-  std::size_t operator()(const ModuleDependencyID &id) const {
-    auto underlyingKindValue = static_cast<UnderlyingKindType>(id.second);
-
-    return (hash<string>()(id.first) ^
-            (hash<UnderlyingKindType>()(underlyingKindValue)));
-  }
-};
-} // namespace std
-
 namespace swift {
 
 class ModuleDependenciesCacheSerializer {

lib/DependencyScan/ScanDependencies.cpp

@@ -36,6 +36,7 @@
 #include "swift/Strings.h"
 #include "clang/Basic/Module.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/ADT/SetOperations.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSet.h"
@@ -47,6 +48,7 @@
 #include <set>
 #include <string>
 #include <sstream>
+#include <algorithm>
 
 using namespace swift;
 using namespace swift::dependencies;
@@ -157,6 +159,152 @@ static void findAllImportedClangModules(ASTContext &ctx, StringRef moduleName,
   }
 }
 
+// Get all dependencies's IDs of this module from its cached
+// ModuleDependencyInfo
+static ArrayRef<ModuleDependencyID>
+getDependencies(const ModuleDependencyID &moduleID,
+                const ModuleDependenciesCache &cache) {
+  const auto &optionalModuleInfo =
+      cache.findDependency(moduleID.first, moduleID.second);
+  assert(optionalModuleInfo.has_value());
+  return optionalModuleInfo.value()->getModuleDependencies();
+}
+
+/// Implements a topological sort via recursion and reverse postorder DFS.
+/// Does not bother handling cycles, relying on a DAG guarantee by the client.
+static std::vector<ModuleDependencyID>
+computeTopologicalSortOfExplicitDependencies(
+    const ModuleDependencyIDSetVector &allModules,
+    const ModuleDependenciesCache &cache) {
+  // Must be explicitly-typed to allow recursion
+  std::function<void(const ModuleDependencyID &,
+                     std::stack<ModuleDependencyID> &,
+                     std::unordered_set<ModuleDependencyID> &,
+                     std::vector<ModuleDependencyID> &)>
+      visit;
+  visit = [&visit, &cache](const ModuleDependencyID &moduleID,
+                           std::stack<ModuleDependencyID> &stack,
+                           std::unordered_set<ModuleDependencyID> &visited,
+                           std::vector<ModuleDependencyID> &result) {
+    // Mark this node as visited -- we are done if it already was.
+    if (!visited.insert(moduleID).second)
+      return;
+
+    // Otherwise, visit each adjacent node.
+    for (const auto &succID : getDependencies(moduleID, cache)) {
+      // We don't worry if successor is already in this current stack,
+      // since that would mean we have found a cycle, which should not
+      // be possible because we checked for cycles earlier.
+      stack.push(succID);
+      visit(succID, stack, visited, result);
+      auto top = stack.top();
+      stack.pop();
+      assert(top == succID);
+    }
+
+    // Add to the result.
+    result.push_back(moduleID);
+  };
+
+  std::unordered_set<ModuleDependencyID> visited;
+  std::vector<ModuleDependencyID> result;
+  std::stack<ModuleDependencyID> stack;
+  for (const auto &modID : allModules) {
+    assert(stack.empty());
+    stack.push(modID);
+    visit(modID, stack, visited, result);
+    auto top = stack.top();
+    stack.pop();
+    assert(top == modID);
+  }
+
+  std::reverse(result.begin(), result.end());
+  return result;
+}
+
+/// For each module in the graph, compute a set of all its dependencies
+/// direct *and* transitive.
+static std::unordered_map<ModuleDependencyID,
+                          std::set<ModuleDependencyID>>
+computeTransitiveClosureOfExplicitDependencies(
+    const std::vector<ModuleDependencyID> &topologicallySortedModuleList,
+    const ModuleDependenciesCache &cache) {
+  std::unordered_map<ModuleDependencyID, std::set<ModuleDependencyID>>
+      result;
+  for (const auto &modID : topologicallySortedModuleList)
+    result[modID] = {modID};
+
+  // Traverse the set of modules in reverse topological order, assimilating
+  // transitive closures
+  for (auto it = topologicallySortedModuleList.rbegin(),
+            end = topologicallySortedModuleList.rend();
+       it != end; ++it) {
+    const auto &modID = *it;
+    auto &modReachableSet = result[modID];
+    for (const auto &succID : getDependencies(modID, cache)) {
+      const auto &succReachableSet = result[succID];
+      llvm::set_union(modReachableSet, succReachableSet);
+    }
+  }
+  return result;
+}
+
+static void
+resolveExplicitModuleInputs(ModuleDependencyID moduleID,
+                            const ModuleDependencyInfo &resolvingDepInfo,
+                            const std::set<ModuleDependencyID> &dependencies,
+                            ModuleDependenciesCache &cache) {
+  auto resolvingInterfaceDepDetails =
+      resolvingDepInfo.getAsSwiftInterfaceModule();
+  assert(resolvingInterfaceDepDetails &&
+         "Expected Swift Interface dependency.");
+
+  auto commandLine = resolvingInterfaceDepDetails->buildCommandLine;
+  for (const auto &depModuleID : dependencies) {
+    const auto optionalDepInfo =
+        cache.findDependency(depModuleID.first, depModuleID.second);
+    assert(optionalDepInfo.has_value());
+    const auto depInfo = optionalDepInfo.value();
+    switch (depModuleID.second) {
+    case swift::ModuleDependencyKind::SwiftInterface: {
+      auto interfaceDepDetails = depInfo->getAsSwiftInterfaceModule();
+      assert(interfaceDepDetails && "Expected Swift Interface dependency.");
+      commandLine.push_back("-swift-module-file=" + depModuleID.first + "=" +
+                            interfaceDepDetails->moduleOutputPath);
+    } break;
+    case swift::ModuleDependencyKind::SwiftBinary: {
+      auto binaryDepDetails = depInfo->getAsSwiftBinaryModule();
+      assert(binaryDepDetails && "Expected Swift Binary Module dependency.");
+      commandLine.push_back("-swift-module-file=" + depModuleID.first + "=" +
+                            binaryDepDetails->compiledModulePath);
+    } break;
+    case swift::ModuleDependencyKind::SwiftPlaceholder: {
+      auto placeholderDetails = depInfo->getAsPlaceholderDependencyModule();
+      assert(placeholderDetails && "Expected Swift Placeholder dependency.");
+      commandLine.push_back("-swift-module-file=" + depModuleID.first + "=" +
+                            placeholderDetails->compiledModulePath);
+    } break;
+    case swift::ModuleDependencyKind::Clang: {
+      auto clangDepDetails = depInfo->getAsClangModule();
+      assert(binaryDepDetails && "Expected Clang Module dependency.");
+      commandLine.push_back("-Xcc");
+      commandLine.push_back("-fmodule-file=" + depModuleID.first + "=" +
+                            clangDepDetails->pcmOutputPath);
+      commandLine.push_back("-Xcc");
+      commandLine.push_back("-fmodule-map-file=" +
+                            clangDepDetails->moduleMapFile);
+    } break;
+    default:
+      llvm_unreachable("Unhandled dependency kind.");
+    }
+  }
+
+  // Update the dependency in the cache with the modified command-line.
+  auto dependencyInfoCopy = resolvingDepInfo;
+  dependencyInfoCopy.updateCommandLine(commandLine);
+  cache.updateDependency(moduleID, dependencyInfoCopy);
+}
+
 /// Resolve the direct dependencies of the given module.
 static ArrayRef<ModuleDependencyID>
 resolveDirectDependencies(CompilerInstance &instance, ModuleDependencyID module,
@@ -1475,8 +1623,29 @@ swift::dependencies::performModuleScan(CompilerInstance &instance,
   if (diagnoseCycle(instance, cache, mainModuleID, ASTDelegate))
     return std::make_error_code(std::errc::not_supported);
 
+  // Resolve Swift dependency command-line arguments
+  // Must happen after cycle detection, because it relies on
+  // the DAG property of the dependency graph.
+  auto topoSortedModuleList =
+      computeTopologicalSortOfExplicitDependencies(allModules, cache);
+  auto moduleTransitiveClosures =
+      computeTransitiveClosureOfExplicitDependencies(topoSortedModuleList,
+                                                     cache);
+  for (const auto &dependencyClosure : moduleTransitiveClosures) {
+    auto &modID = dependencyClosure.first;
+    // For main module or binary modules, no command-line to resolve.
+    // For Clang modules, their dependencies are resolved by the clang Scanner
+    // itself for us.
+    if (modID.second != ModuleDependencyKind::SwiftInterface)
+      continue;
+    auto optionalDeps = cache.findDependency(modID.first, modID.second);
+    assert(optionalDeps.has_value());
+    auto deps = optionalDeps.value();
+    resolveExplicitModuleInputs(modID, *deps, dependencyClosure.second, cache);
+  }
+
   auto dependencyGraph = generateFullDependencyGraph(
-      instance, cache, ASTDelegate, allModules.getArrayRef());
+      instance, cache, ASTDelegate, topoSortedModuleList);
   // Update the dependency tracker.
   if (auto depTracker = instance.getDependencyTracker()) {
     for (auto module : allModules) {

test/ScanDependencies/explicit-swift-dependencies.swift

@@ -0,0 +1,55 @@
+// RUN: %empty-directory(%t)
+// RUN: mkdir -p %t/clang-module-cache
+
+// RUN: %target-swift-frontend -scan-dependencies -module-cache-path %t/clang-module-cache %s -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
+// Check the contents of the JSON output
+// RUN: %FileCheck %s < %t/deps.json
+
+// REQUIRES: executable_test
+// REQUIRES: objc_interop
+
+
+import F
+
+// CHECK: "mainModuleName": "deps"
+
+/// --------Main module
+// CHECK-LABEL: "modulePath": "deps.swiftmodule",
+// CHECK-NEXT: sourceFiles
+// CHECK-NEXT: explicit-swift-dependencies.swift
+// CHECK-NEXT: ],
+// CHECK-NEXT: "directDependencies": [
+// CHECK-DAG:     "swift": "F"
+// CHECK-DAG:     "swift": "Swift"
+// CHECK-DAG:     "swift": "SwiftOnoneSupport"
+// CHECK-DAG:     "swift": "_Concurrency"
+// CHECK-DAG:     "clang": "_SwiftConcurrencyShims"
+// CHECK-DAG:     "swift": "_StringProcessing"
+// CHECK: ],
+
+/// --------Swift module F
+// CHECK: "modulePath": "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule",
+// CHECK: directDependencies
+// CHECK-NEXT: {
+// CHECK-DAG:   "clang": "F"
+// CHECK-DAG:   "swift": "Swift"
+// CHECK-DAG:   "swift": "SwiftOnoneSupport"
+
+
+// CHECK: "commandLine": [
+// CHECK-NEXT:            "-frontend",
+// CHECK-NEXT:            "-compile-module-from-interface",
+// CHECK-NEXT:            "-target",
+// ...
+// CHECK:                 "-explicit-interface-module-build",
+// CHECK-NEXT:            "-disable-implicit-swift-modules",
+// CHECK-NEXT:            "-Xcc",
+// CHECK-NEXT:            "-fno-implicit-modules",
+// CHECK-NEXT:            "-Xcc",
+// CHECK-NEXT:            "-fno-implicit-module-maps",
+// CHECK-NEXT:            "-o",
+// CHECK-NEXT:            "{{.*}}{{/|\\}}F-{{.*}}.swiftmodule"
+// CHECK-DAG:             "-swift-module-file=Swift={{.*}}{{/|\\}}Swift-{{.*}}.swiftmodule"
+// CHECK-DAG:             "-swift-module-file=SwiftOnoneSupport={{.*}}{{/|\\}}SwiftOnoneSupport-{{.*}}.swiftmodule"
+// CHECK-DAG:             "-fmodule-file=F={{.*}}{{/|\\}}F-{{.*}}.pcm",
+// CHECK-DAG:             "-fmodule-file=SwiftShims={{.*}}{{/|\\}}SwiftShims-{{.*}}.pcm",