[Dependency Scanning] Add entry-point to DependencyScanningTool and the corresponding C API for an import prescan operation

Author: artemcm

include/swift-c/DependencyScan/DependencyScan.h

@@ -164,6 +164,11 @@ typedef struct {
   depscan_dependency_set_t* module_set;
 } depscan_dependency_result_t;
 
+typedef struct {
+  /// The complete list of imports discovered
+  ds_string_set_t* import_set;
+} depscan_prescan_result_t;
+
 //=== Dependency Result Functions -----------------------------------------===//
 
 DEPSCAN_PUBLIC void
@@ -178,6 +183,9 @@ depscan_dependency_set_dispose(depscan_dependency_set_t *set);
 DEPSCAN_PUBLIC void
 depscan_dependency_result_dispose(depscan_dependency_result_t *result);
 
+DEPSCAN_PUBLIC void
+depscan_prescan_result_dispose(depscan_prescan_result_t *result);
+
 //=== Scanner Functions ---------------------------------------------------===//
 
 /// Container of the configuration state and shared cache for dependency scanning.
@@ -195,6 +203,12 @@ depscan_scan_dependencies(depscan_scanner_t* scanner,
                           int argc,
                           const char *const *argv);
 
+DEPSCAN_PUBLIC depscan_prescan_result_t*
+depscan_prescan_dependencies(depscan_scanner_t* scanner,
+                             const char *working_directory,
+                             int argc,
+                             const char *const *argv);
+
 DEPSCAN_END_DECLS
 
 #endif // SWIFT_C_DEPENDENCY_SCAN_H

include/swift/DependencyScan/DependencyScanningTool.h

@@ -35,11 +35,18 @@ class DependencyScanningTool {
   /// placeholder modules.
   ///
   /// \returns a \c StringError with the diagnostic output if errors
-  /// occurred, \c FullDependencies otherwise.
+  /// occurred, \c depscan_dependency_result_t otherwise.
   llvm::ErrorOr<depscan_dependency_result_t*>
   getDependencies(ArrayRef<const char *> Command,
                   const llvm::StringSet<> &PlaceholderModules);
 
+  /// Collect the set of imports for the input module
+  ///
+  /// \returns a \c StringError with the diagnostic output if errors
+  /// occurred, \c depscan_prescan_result_t otherwise.
+  llvm::ErrorOr<depscan_prescan_result_t*>
+  getImports(ArrayRef<const char *> Command);
+
   /// Collect the full module depenedency graph for the input collection of
   /// module names (batch inputs) and output them to the
   /// BatchScanInput-specified output locations.

include/swift/DependencyScan/ScanDependencies.h

@@ -58,14 +58,18 @@ llvm::ErrorOr<depscan_dependency_result_t*>
 performModuleScan(CompilerInstance &instance,
                   ModuleDependenciesCache &cache);
 
+/// Scans the main module of \c instance for all direct module imports
+llvm::ErrorOr<depscan_prescan_result_t*>
+performModulePrescan(CompilerInstance &instance);
+
 /// Batch scan the dependencies for modules specified in \c batchInputFile.
 std::vector<llvm::ErrorOr<depscan_dependency_result_t*>>
 performBatchModuleScan(CompilerInstance &instance,
                        ModuleDependenciesCache &cache, llvm::StringSaver &saver,
                        const std::vector<BatchScanInput> &BatchInput);
 
 /// Batch prescan the imports of modules specified in \c batchInputFile.
-std::vector<llvm::ErrorOr<std::vector<std::string>>>
+std::vector<llvm::ErrorOr<depscan_prescan_result_t*>>
 performBatchModulePrescan(CompilerInstance &instance,
                           ModuleDependenciesCache &cache,
                           llvm::StringSaver &saver,

lib/DependencyScan/CMakeLists.txt

@@ -16,15 +16,4 @@ target_link_libraries(SwiftScan INTERFACE
 target_link_libraries(SwiftScan PRIVATE
     swiftClangImporter
     swiftDemangling
-    swiftFrontend
-    swiftIDE
-    swiftImmediate
-    swiftIndex
-    swiftIRGen
-    swiftOption
-    swiftPrintAsObjC
-    swiftSerialization
-    swiftSIL
-    swiftSILGen
-    swiftSILOptimizer
-    swiftTBDGen)
+    swiftFrontend)

lib/DependencyScan/DependencyScanningTool.cpp

@@ -47,6 +47,23 @@ DependencyScanningTool::getDependencies(
   return Dependencies;
 }
 
+llvm::ErrorOr<depscan_prescan_result_t *>
+DependencyScanningTool::getImports(ArrayRef<const char *> Command) {
+  // The primary instance used to scan the query Swift source-code
+  auto InstanceOrErr = initCompilerInstanceForScan(Command);
+  if (std::error_code EC = InstanceOrErr.getError())
+    return EC;
+  auto Instance = std::move(*InstanceOrErr);
+
+  // Execute the scanning action, retreiving the in-memory result
+  auto DependenciesOrErr = performModulePrescan(*Instance.get());
+  if (DependenciesOrErr.getError())
+    return std::make_error_code(std::errc::not_supported);
+  auto Dependencies = std::move(*DependenciesOrErr);
+
+  return Dependencies;
+}
+
 std::vector<llvm::ErrorOr<depscan_dependency_result_t *>>
 DependencyScanningTool::getDependencies(
     ArrayRef<const char *> Command,
@@ -135,6 +152,23 @@ depscan_scan_dependencies(depscan_scanner_t *scanner,
   return DependencyGraph;
 }
 
+depscan_prescan_result_t *
+depscan_prescan_dependencies(depscan_scanner_t *scanner,
+                          const char *working_directory, int argc,
+                          const char *const *argv) {
+  DependencyScanningTool *ScanningTool = unwrap(scanner);
+  std::vector<const char *> Compilation;
+  for (int i = 0; i < argc; ++i)
+    Compilation.push_back(argv[i]);
+
+  // Execute the scan and bridge the result
+  auto PreScanResult = ScanningTool->getImports(Compilation);
+  if (PreScanResult.getError())
+    return nullptr;
+  auto ImportSet = std::move(*PreScanResult);
+  return ImportSet;
+}
+
 void depscan_dependency_info_details_dispose(
     depscan_module_details_t *details) {
   switch (details->kind) {
@@ -195,3 +229,8 @@ void depscan_dependency_result_dispose(depscan_dependency_result_t *result) {
   depscan_dependency_set_dispose(result->module_set);
   delete result;
 }
+
+void depscan_prescan_result_dispose(depscan_prescan_result_t *result) {
+  depscan_string_set_dispose(result->import_set);
+  delete result;
+}

lib/DependencyScan/ScanDependencies.cpp

@@ -11,7 +11,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/DependencyScan/ScanDependencies.h"
-#include "swift/DependencyScan/DSString.h"
 #include "swift/AST/ASTContext.h"
 #include "swift/AST/Decl.h"
 #include "swift/AST/DiagnosticEngine.h"
@@ -24,6 +23,7 @@
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/STLExtras.h"
 #include "swift/ClangImporter/ClangImporter.h"
+#include "swift/DependencyScan/DSString.h"
 #include "swift/Frontend/Frontend.h"
 #include "swift/Frontend/FrontendOptions.h"
 #include "swift/Frontend/ModuleInterfaceLoader.h"
@@ -472,14 +472,13 @@ getAsClangDependencyModule(const depscan_module_details_t *details) {
   return nullptr;
 }
 
-static void
-writePrescanJSON(llvm::raw_ostream &out,
-                 const std::vector<std::string> &moduleDependencies) {
+static void writePrescanJSON(llvm::raw_ostream &out,
+                             const depscan_prescan_result_t *importSet) {
   // Write out a JSON containing all main module imports.
   out << "{\n";
   SWIFT_DEFER { out << "}\n"; };
 
-  writeJSONSingleField(out, "imports", moduleDependencies, 0, false);
+  writeJSONSingleField(out, "imports", importSet, 0, false);
 }
 
 static void writeJSON(llvm::raw_ostream &out,
@@ -984,8 +983,7 @@ forEachBatchEntry(CompilerInstance &instance, ModuleDependenciesCache &cache,
 }
 
 static ModuleDependencies
-identifyMainModuleDependencies(CompilerInstance &instance,
-                               ModuleDependenciesCache &cache) {
+identifyMainModuleDependencies(CompilerInstance &instance) {
   ModuleDecl *mainModule = instance.getMainModule();
   // Main module file name.
   auto newExt = file_types::getExtension(file_types::TY_SwiftModuleFile);
@@ -1105,10 +1103,13 @@ bool swift::dependencies::prescanDependencies(CompilerInstance &instance) {
   }
 
   // Execute import prescan, and write JSON output to the output stream
-  auto mainDependencies = identifyMainModuleDependencies(instance, cache);
+  auto importSetOrErr = performModulePrescan(instance);
+  if (importSetOrErr.getError())
+    return true;
+  auto importSet = std::move(*importSetOrErr);
 
   // Serialize and output main module dependencies only and exit.
-  writePrescanJSON(out, mainDependencies.getModuleDependencies());
+  writePrescanJSON(out, importSet);
   // 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
@@ -1186,7 +1187,7 @@ swift::dependencies::performModuleScan(CompilerInstance &instance,
   ModuleDecl *mainModule = instance.getMainModule();
 
   // First, identify the dependencies of the main module
-  auto mainDependencies = identifyMainModuleDependencies(instance, cache);
+  auto mainDependencies = identifyMainModuleDependencies(instance);
 
   // Add the main module.
   StringRef mainModuleName = mainModule->getNameStr();
@@ -1261,6 +1262,15 @@ swift::dependencies::performModuleScan(CompilerInstance &instance,
   return dependencyGraph;
 }
 
+llvm::ErrorOr<depscan_prescan_result_t *>
+swift::dependencies::performModulePrescan(CompilerInstance &instance) {
+  // Execute import prescan, and write JSON output to the output stream
+  auto mainDependencies = identifyMainModuleDependencies(instance);
+  depscan_prescan_result_t *importSet = new depscan_prescan_result_t;
+  importSet->import_set = create_set(mainDependencies.getModuleDependencies());
+  return importSet;
+}
+
 std::vector<llvm::ErrorOr<depscan_dependency_result_t *>>
 swift::dependencies::performBatchModuleScan(
     CompilerInstance &instance, ModuleDependenciesCache &cache,
@@ -1330,11 +1340,11 @@ swift::dependencies::performBatchModuleScan(
   return batchScanResult;
 }
 
-std::vector<llvm::ErrorOr<std::vector<std::string>>>
+std::vector<llvm::ErrorOr<depscan_prescan_result_t *>>
 swift::dependencies::performBatchModulePrescan(
     CompilerInstance &instance, ModuleDependenciesCache &cache,
     llvm::StringSaver &saver, const std::vector<BatchScanInput> &batchInput) {
-  std::vector<llvm::ErrorOr<std::vector<std::string>>> batchPrescanResult;
+  std::vector<llvm::ErrorOr<depscan_prescan_result_t *>> batchPrescanResult;
 
   // Perform a full dependency scan for each batch entry module
   forEachBatchEntry(
@@ -1377,7 +1387,9 @@ swift::dependencies::performBatchModulePrescan(
           return;
         }
 
-        batchPrescanResult.push_back(rootDeps->getModuleDependencies());
+        depscan_prescan_result_t *importSet = new depscan_prescan_result_t;
+        importSet->import_set = create_set(rootDeps->getModuleDependencies());
+        batchPrescanResult.push_back(importSet);
       });
 
   return batchPrescanResult;