[Dependency scanning] Add implicit Swift and SwiftOnoneSupport dependencies

Author: DougGregor

include/swift/Frontend/Frontend.h

@@ -346,6 +346,9 @@ class CompilerInvocation {
     return ImplicitStdlibKind::Stdlib;
   }
 
+  /// Whether the Swift -Onone support library should be implicitly imported.
+  bool shouldImportSwiftONoneSupport() const;
+
   /// Performs input setup common to these tools:
   /// sil-opt, sil-func-extractor, sil-llvm-gen, and sil-nm.
   /// Return value includes the buffer so caller can keep it alive.

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -83,6 +83,12 @@ bool ArgsToFrontendOptionsConverter::convert(
 
   Opts.TrackSystemDeps |= Args.hasArg(OPT_track_system_dependencies);
 
+  // Always track system dependencies when scanning dependencies.
+  if (const Arg *ModeArg = Args.getLastArg(OPT_modes_Group)) {
+    if (ModeArg->getOption().matches(OPT_scan_dependencies))
+      Opts.TrackSystemDeps = true;
+  }
+
   Opts.SerializeModuleInterfaceDependencyHashes |=
     Args.hasArg(OPT_serialize_module_interface_dependency_hashes);
 

lib/Frontend/Frontend.cpp

@@ -687,11 +687,10 @@ std::unique_ptr<SILModule> CompilerInstance::takeSILModule() {
 /// builds. This allows for use of popular specialized functions
 /// from the standard library, which makes the non-optimized builds
 /// execute much faster.
-static bool shouldImplicityImportSwiftOnoneSupportModule(
-    const CompilerInvocation &Invocation) {
-  if (Invocation.getImplicitStdlibKind() != ImplicitStdlibKind::Stdlib)
+bool CompilerInvocation::shouldImportSwiftONoneSupport() const {
+  if (getImplicitStdlibKind() != ImplicitStdlibKind::Stdlib)
     return false;
-  if (Invocation.getSILOptions().shouldOptimize())
+  if (getSILOptions().shouldOptimize())
     return false;
 
   // If we are not executing an action that has a dependency on
@@ -706,7 +705,7 @@ static bool shouldImplicityImportSwiftOnoneSupportModule(
   //
   // This optimization is disabled by -track-system-dependencies to preserve
   // the explicit dependency.
-  const auto &options = Invocation.getFrontendOptions();
+  const auto &options = getFrontendOptions();
   return options.TrackSystemDeps
       || FrontendOptions::doesActionGenerateSIL(options.RequestedAction);
 }
@@ -720,7 +719,7 @@ ImplicitImportInfo CompilerInstance::getImplicitImportInfo() const {
   for (auto &moduleStr : frontendOpts.getImplicitImportModuleNames())
     imports.ModuleNames.push_back(Context->getIdentifier(moduleStr));
 
-  if (shouldImplicityImportSwiftOnoneSupportModule(Invocation))
+  if (Invocation.shouldImportSwiftONoneSupport())
     imports.ModuleNames.push_back(Context->getIdentifier(SWIFT_ONONE_SUPPORT));
 
   imports.ShouldImportUnderlyingModule = frontendOpts.ImportUnderlyingModule;

lib/Frontend/ModuleDependencyScanner.cpp

@@ -104,8 +104,7 @@ ErrorOr<ModuleDependencies> ModuleDependencyScanner::scanInterfaceFile(
   unsigned bufferID = Ctx.SourceMgr.addNewSourceBuffer(std::move(interfaceBuf.get()));
   auto moduleDecl = ModuleDecl::create(moduleName, Ctx);
   auto sourceFile = new (Ctx) SourceFile(
-      *moduleDecl, SourceFileKind::Interface, bufferID,
-      SourceFile::ImplicitModuleImportKind::None);
+      *moduleDecl, SourceFileKind::Interface, bufferID);
 
   // Create a module filename.
   // FIXME: Query the module interface loader to determine an appropriate

lib/FrontendTool/FrontendTool.cpp

@@ -1267,8 +1267,7 @@ static bool performCompile(CompilerInstance &Instance,
     return Context.hadError();
 
   if (Action == FrontendOptions::ActionType::ScanDependencies) {
-    scanDependencies(Context, Instance.getMainModule(),
-                     Instance.getDependencyTracker(), opts);
+    scanDependencies(Instance);
   }
 
   (void)emitMakeDependenciesIfNeeded(Context.Diags,

lib/FrontendTool/ScanDependencies.cpp

@@ -22,7 +22,9 @@
 #include "swift/Basic/Defer.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/STLExtras.h"
+#include "swift/Frontend/Frontend.h"
 #include "swift/Frontend/FrontendOptions.h"
+#include "swift/Strings.h"
 #include "clang/Basic/Module.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringMap.h"
@@ -316,9 +318,11 @@ static void writeJSON(llvm::raw_ostream &out,
   }
 }
 
-bool swift::scanDependencies(ASTContext &Context, ModuleDecl *mainModule,
-                             DependencyTracker *depTracker,
-                             const FrontendOptions &opts) {
+bool swift::scanDependencies(CompilerInstance &instance) {
+  ASTContext &Context = instance.getASTContext();
+  ModuleDecl *mainModule = instance.getMainModule();
+  const CompilerInvocation &invocation = instance.getInvocation();
+  const FrontendOptions &opts = invocation.getFrontendOptions();
 
   std::string path = opts.InputsAndOutputs.getSingleOutputFilename();
   std::error_code EC;
@@ -349,15 +353,43 @@ bool swift::scanDependencies(ASTContext &Context, ModuleDecl *mainModule,
       mainDependencies.addModuleDependencies(*sf, alreadyAddedModules);
     }
 
+    const auto &importInfo = mainModule->getImplicitImportInfo();
+
+    // Swift standard library.
+    switch (importInfo.StdlibKind) {
+    case ImplicitStdlibKind::None:
+    case ImplicitStdlibKind::Builtin:
+      break;
+
+    case ImplicitStdlibKind::Stdlib:
+      mainDependencies.addModuleDependency("Swift", alreadyAddedModules);
+      break;
+    }
+
+    // Swift -Onone support library.
+    if (invocation.shouldImportSwiftONoneSupport()) {
+      mainDependencies.addModuleDependency(
+          SWIFT_ONONE_SUPPORT, alreadyAddedModules);
+    }
+
+    // Add any implicit module names.
+    for (const auto &moduleName : importInfo.ModuleNames) {
+      mainDependencies.addModuleDependency(moduleName.str(), alreadyAddedModules);
+    }
+
+    // Already-loaded, implicitly imported module names.
+    for (const auto &module : importInfo.AdditionalModules) {
+      mainDependencies.addModuleDependency(module.first->getNameStr(), alreadyAddedModules);
+    }
+
     // Add the bridging header.
-    StringRef implicitHeaderPath = opts.ImplicitObjCHeaderPath;
-    if (!implicitHeaderPath.empty()) {
-      mainDependencies.addBridgingHeader(implicitHeaderPath);
+    if (!importInfo.BridgingHeaderPath.empty()) {
+      mainDependencies.addBridgingHeader(importInfo.BridgingHeaderPath);
     }
 
     // If we are to import the underlying Clang module of the same name,
     // add a dependency with the same name to trigger the search.
-    if (opts.ImportUnderlyingModule) {
+    if (importInfo.ShouldImportUnderlyingModule) {
       mainDependencies.addModuleDependency(mainModule->getName().str(),
                                            alreadyAddedModules);
     }
@@ -389,7 +421,7 @@ bool swift::scanDependencies(ASTContext &Context, ModuleDecl *mainModule,
   writeJSON(out, Context, cache, allModules.getArrayRef());
 
   // Update the dependency tracker.
-  if (depTracker) {
+  if (auto depTracker = instance.getDependencyTracker()) {
     for (auto module : allModules) {
       auto deps = cache.findDependencies(module.first, module.second);
       if (!deps)

lib/FrontendTool/ScanDependencies.h

@@ -15,15 +15,10 @@
 
 namespace swift {
 
-class ASTContext;
-class DependencyTracker;
-class FrontendOptions;
-class ModuleDecl;
+class CompilerInstance;
 
-/// Scans the dependencies of \c mainModule.
-bool scanDependencies(ASTContext &Context, ModuleDecl *mainModule,
-                      DependencyTracker *depTracker,
-                      const FrontendOptions &opts);
+/// Scans the dependencies of the main module of \c instance.
+bool scanDependencies(CompilerInstance &instance);
 
 } // end namespace swift
 

test/ScanDependencies/module_deps.swift

@@ -36,6 +36,12 @@ import E
 // CHECK-NEXT: "swift": "E"
 // 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: {
@@ -78,6 +84,13 @@ import E
 // CHECK: "moduleInterfacePath"
 // CHECK-SAME: E.swiftinterface
 
+/// --------Swift module Swift
+// CHECK-LABEL: "modulePath": "Swift.swiftmodule",
+
+// CHECK: directDependencies
+// CHECK-NEXT: {
+// CHECK-NEXT: "clang": "SwiftShims"
+
 /// --------Swift module A
 // CHECK-LABEL: "modulePath": "A.swiftmodule",
 
@@ -98,13 +111,6 @@ import E
 // CHECK-NEXT: "clang": "A"
 // CHECK-NEXT: }
 
-/// --------Swift module Swift
-// CHECK-LABEL: "modulePath": "Swift.swiftmodule",
-
-// CHECK: directDependencies
-// CHECK-NEXT: {
-// CHECK-NEXT: "clang": "SwiftShims"
-
 /// --------Clang module SwiftShims
 // CHECK-LABEL: "modulePath": "SwiftShims.pcm",