[Dependency Scanning] Add swift dependency compile arguments required for self-contained commands

- '-o <output_path>'
- '-disable-implicit-swift-modules'
- '-Xcc -fno-implicit-modules' and '-Xcc -fno-implicit-module-maps'
- '-candidate-module-file'

These were previously supplied by the driver. Instead, they will now be ready to be run directly from the dependency scanner's output.

Author: artemcm

lib/ClangImporter/ClangModuleDependencyScanner.cpp

@@ -153,15 +153,15 @@ void ClangImporter::recordModuleDependencies(
     // We are using Swift frontend mode.
     swiftArgs.push_back("-frontend");
 
-    // We pass the entire argument list via -Xcc, so the invocation should
-    // use extra clang options alone.
-    swiftArgs.push_back("-only-use-extra-clang-opts");
-
     // Swift frontend action: -emit-pcm
     swiftArgs.push_back("-emit-pcm");
     swiftArgs.push_back("-module-name");
     swiftArgs.push_back(clangModuleDep.ID.ModuleName);
 
+    // We pass the entire argument list via -Xcc, so the invocation should
+    // use extra clang options alone.
+    swiftArgs.push_back("-only-use-extra-clang-opts");
+
     auto pcmPath = moduleCacheRelativeLookupModuleOutput(
         clangModuleDep.ID, ModuleOutputKind::ModuleFile,
         getModuleCachePathFromClang(getClangInstance()));

lib/DependencyScan/ScanDependencies.cpp

@@ -176,16 +176,14 @@ static std::vector<ModuleDependencyID>
 computeTopologicalSortOfExplicitDependencies(
     const ModuleDependencyIDSetVector &allModules,
     const ModuleDependenciesCache &cache) {
+  std::unordered_set<ModuleDependencyID> visited;
+  std::vector<ModuleDependencyID> result;
+  std::stack<ModuleDependencyID> stack;
+
   // 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) {
+  std::function<void(const ModuleDependencyID &)> visit;
+  visit = [&visit, &cache, &visited, &result,
+           &stack](const ModuleDependencyID &moduleID) {
     // Mark this node as visited -- we are done if it already was.
     if (!visited.insert(moduleID).second)
       return;
@@ -196,7 +194,7 @@ computeTopologicalSortOfExplicitDependencies(
       // 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);
+      visit(succID);
       auto top = stack.top();
       stack.pop();
       assert(top == succID);
@@ -206,13 +204,10 @@ computeTopologicalSortOfExplicitDependencies(
     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);
+    visit(modID);
     auto top = stack.top();
     stack.pop();
     assert(top == modID);
@@ -222,13 +217,15 @@ computeTopologicalSortOfExplicitDependencies(
   return result;
 }
 
-/// For each module in the graph, compute a set of all its dependencies
+/// 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) {
+  // The usage of an ordered ::set is important to ensure the
+  // dependencies are listed in a deterministic order.
   std::unordered_map<ModuleDependencyID, std::set<ModuleDependencyID>>
       result;
   for (const auto &modID : topologicallySortedModuleList)
@@ -286,7 +283,7 @@ resolveExplicitModuleInputs(ModuleDependencyID moduleID,
     } break;
     case swift::ModuleDependencyKind::Clang: {
       auto clangDepDetails = depInfo->getAsClangModule();
-      assert(binaryDepDetails && "Expected Clang Module dependency.");
+      assert(clangDepDetails && "Expected Clang Module dependency.");
       commandLine.push_back("-Xcc");
       commandLine.push_back("-fmodule-file=" + depModuleID.first + "=" +
                             clangDepDetails->pcmOutputPath);

lib/Serialization/ModuleDependencyScanner.cpp

@@ -112,21 +112,38 @@ ErrorOr<ModuleDependencyInfo> ModuleDependencyScanner::scanInterfaceFile(
                                               StringRef(),
                                               SourceLoc(),
                 [&](ASTContext &Ctx, ModuleDecl *mainMod,
-                    ArrayRef<StringRef> Args,
+                    ArrayRef<StringRef> BaseArgs,
                     ArrayRef<StringRef> PCMArgs, StringRef Hash) {
     assert(mainMod);
     std::string InPath = moduleInterfacePath.str();
     auto compiledCandidates = getCompiledCandidates(Ctx, realModuleName.str(),
                                                     InPath);
+    std::vector<std::string> Args(BaseArgs.begin(), BaseArgs.end());
+
+    // Add explicit Swift dependency compilation flags
+    Args.push_back("-explicit-interface-module-build");
+    Args.push_back("-disable-implicit-swift-modules");
+    Args.push_back("-Xcc"); Args.push_back("-fno-implicit-modules");
+    Args.push_back("-Xcc"); Args.push_back("-fno-implicit-module-maps");
+    for (const auto &candidate : compiledCandidates) {
+      Args.push_back("-candidate-module-file");
+      Args.push_back(candidate);
+    }
 
+    // Compute the output path and add it to the command line
     SmallString<128> outputPathBase(moduleCachePath);
     llvm::sys::path::append(
         outputPathBase,
         moduleName.str() + "-" + Hash + "." +
             file_types::getExtension(file_types::TY_SwiftModuleFile));
+    Args.push_back("-o");
+    Args.push_back(outputPathBase.str().str());
+
+    std::vector<StringRef> ArgsRefs(Args.begin(), Args.end());
     Result = ModuleDependencyInfo::forSwiftInterfaceModule(
-        outputPathBase.str().str(), InPath, compiledCandidates, Args, PCMArgs,
+        outputPathBase.str().str(), InPath, compiledCandidates, ArgsRefs, PCMArgs,
         Hash, isFramework);
+
     // Open the interface file.
     auto &fs = *Ctx.SourceMgr.getFileSystem();
     auto interfaceBuf = fs.getBufferForFile(moduleInterfacePath);

test/ScanDependencies/module_deps_cache_reuse.swift

@@ -81,7 +81,6 @@ import SubE
 // CHECK-DAG:     "swift": "SwiftOnoneSupport"
 // CHECK: ],
 
-
 /// --------Swift module G
 // CHECK-LABEL: "modulePath": "{{.*}}{{/|\\}}G-{{.*}}.swiftmodule"
 // CHECK: "directDependencies"