[Dependency Scanner] Add option to execute an import prescan

With this option enabled, the dependency scanner gathers all import statements in source files of the main module (non-transitive) and outputs a list of imported modules.
This will be used by build systems and the swift-driver as a way to avoid redundant re-scanning in incremental contexts.

Author: artemcm

include/swift/Frontend/FrontendOptions.h

@@ -269,6 +269,10 @@ class FrontendOptions {
   /// built and given to the compiler invocation.
   bool DisableImplicitModules = false;
 
+  /// When performing a dependency scanning action, only identify and output all imports
+  /// of the main Swift module's source files.
+  bool ImportPrescan = false;
+
   /// The different modes for validating TBD against the LLVM IR.
   enum class TBDValidationMode {
     Default,        ///< Do the default validation for the current platform.

include/swift/Option/FrontendOptions.td

@@ -226,8 +226,11 @@ def placeholder_dependency_module_map
 def batch_scan_input_file
   : Separate<["-"], "batch-scan-input-file">, MetaVarName<"<path>">,
     HelpText<"Specify a JSON file containing modules to perform batch dependencies scanning">;
-}
 
+def import_prescan : Flag<["-"], "import-prescan">,
+   HelpText<"When performing a dependency scan, only dentify all imports of the main Swift module sources">;
+
+}
 
 // HIDDEN FLAGS
 let Flags = [FrontendOption, NoDriverOption, HelpHidden] in {

lib/Driver/Driver.cpp

@@ -167,10 +167,15 @@ static void validateDependencyScanningArgs(DiagnosticEngine &diags,
                                            const ArgList &args) {
   const Arg *ExternalDependencyMap = args.getLastArg(options::OPT_placeholder_dependency_module_map);
   const Arg *ScanDependencies = args.getLastArg(options::OPT_scan_dependencies);
+  const Arg *Prescan = args.getLastArg(options::OPT_import_prescan);
   if (ExternalDependencyMap && !ScanDependencies) {
     diags.diagnose(SourceLoc(), diag::error_requirement_not_met,
                    "-placeholder-dependency-module-map-file", "-scan-dependencies");
   }
+  if (Prescan && !ScanDependencies) {
+    diags.diagnose(SourceLoc(), diag::error_requirement_not_met,
+                   "-import-prescan", "-scan-dependencies");
+  }
 }
 
 static void validateDebugInfoArgs(DiagnosticEngine &diags,

lib/Frontend/ArgsToFrontendOptionsConverter.cpp

@@ -88,6 +88,8 @@ bool ArgsToFrontendOptionsConverter::convert(
 
   Opts.DisableImplicitModules |= Args.hasArg(OPT_disable_implicit_swift_modules);
 
+  Opts.ImportPrescan |= Args.hasArg(OPT_import_prescan);
+
   // Always track system dependencies when scanning dependencies.
   if (const Arg *ModeArg = Args.getLastArg(OPT_modes_Group)) {
     if (ModeArg->getOption().matches(OPT_scan_dependencies)) {

lib/FrontendTool/ScanDependencies.cpp

@@ -387,6 +387,17 @@ namespace {
   }
 }
 
+static void writePrescanJSON(llvm::raw_ostream &out,
+                             const ModuleDependencies &mainModuleDependencies) {
+  // Write out a JSON containing all main module imports.
+  out << "{\n";
+  SWIFT_DEFER {
+    out << "}\n";
+  };
+
+  writeJSONSingleField(out, "imports", mainModuleDependencies.getModuleDependencies(), 0, false);
+}
+
 static void writeJSON(llvm::raw_ostream &out,
                       CompilerInstance &instance,
                       ModuleDependenciesCache &cache,
@@ -774,6 +785,8 @@ bool swift::scanDependencies(CompilerInstance &instance) {
       "-Xcc", "-target", "-Xcc", instance.getASTContext().LangOpts.Target.str(),
       "-Xcc", apinotesVer
     });
+
+  // Compute Implicit dependencies of the main module
   {
     llvm::StringSet<> alreadyAddedModules;
     for (auto fileUnit : mainModule->getFiles()) {
@@ -820,6 +833,17 @@ bool swift::scanDependencies(CompilerInstance &instance) {
     }
   }
 
+  // If import-prescan is specified, discover and serialize main module dependencies only and exit.
+  if (opts.ImportPrescan) {
+    writePrescanJSON(out, mainDependencies);
+    // This process succeeds regardless of whether any errors occurred.
+    // FIXME: We shouldn't need this, but it's masking bugs in our scanning
+    // logic where we don't create a fresh context when scanning Swift interfaces
+    // that includes their own command-line flags.
+    Context.Diags.resetHadAnyError();
+    return false;
+  }
+
   // Add the main module.
   StringRef mainModuleName = mainModule->getNameStr();
   llvm::SetVector<ModuleDependencyID, std::vector<ModuleDependencyID>,

test/ScanDependencies/prescan_deps.swift

@@ -0,0 +1,23 @@
+// RUN: %empty-directory(%t)
+// RUN: mkdir -p %t/clang-module-cache
+// RUN: %target-swift-frontend -scan-dependencies -import-prescan -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 C
+import E
+import G
+import SubE
+
+// CHECK: "imports": [
+// CHECK-NEXT:  "C",
+// CHECK-NEXT:  "E",
+// CHECK-NEXT:  "G",
+// CHECK-NEXT:  "SubE",
+// CHECK-NEXT:  "Swift",
+// CHECK-NEXT:  "SwiftOnoneSupport"
+// CHECK-NEXT: ]