Dependencies Scanner: report compiled Swift module paths if they are available

include/swift/AST/ASTContext.h

@@ -716,8 +716,11 @@ class ASTContext final {
   ///                compiler.
   /// \param isDWARF \c true if this module loader can load Clang modules
   ///                from DWARF.
+  /// \param IsInterface \c true if this module loader can load Swift textual
+  ///                interface.
   void addModuleLoader(std::unique_ptr<ModuleLoader> loader,
-                       bool isClang = false, bool isDWARF = false);
+                       bool isClang = false, bool isDWARF = false,
+                       bool IsInterface = false);
 
   /// Retrieve the module dependencies for the module with the given name.
   ///
@@ -791,6 +794,8 @@ class ASTContext final {
   /// The loader is owned by the AST context.
   ClangModuleLoader *getDWARFModuleLoader() const;
 
+  /// Retrieve the module interface loader for this ASTContext.
+  ModuleLoader *getModuleInterfaceLoader() const;
 public:
   namelookup::ImportCache &getImportCache() const;
 

include/swift/AST/ModuleDependencies.h

@@ -180,11 +180,11 @@ class ModuleDependencies {
   /// Describe the module dependencies for a Swift module that can be
   /// built from a Swift interface file (\c .swiftinterface).
   static ModuleDependencies forSwiftInterface(
-      const std::string &compiledModulePath,
       const std::string &swiftInterfaceFile,
       ArrayRef<StringRef> buildCommands,
       ArrayRef<StringRef> extraPCMArgs,
       StringRef contextHash) {
+    std::string compiledModulePath;
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
           compiledModulePath, swiftInterfaceFile, buildCommands,
@@ -201,9 +201,8 @@ class ModuleDependencies {
   }
 
   /// Describe the main Swift module.
-  static ModuleDependencies forMainSwiftModule(
-      const std::string &compiledModulePath,
-      ArrayRef<StringRef> extraPCMArgs) {
+  static ModuleDependencies forMainSwiftModule(ArrayRef<StringRef> extraPCMArgs) {
+    std::string compiledModulePath;
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
           compiledModulePath, None, ArrayRef<StringRef>(), extraPCMArgs,

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -202,7 +202,6 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
     std::unique_ptr<llvm::MemoryBuffer> *ModuleSourceInfoBuffer) override;
 
   bool isCached(StringRef DepPath) override;
-
 public:
   static std::unique_ptr<ModuleInterfaceLoader>
   create(ASTContext &ctx, StringRef cacheDir, StringRef prebuiltCacheDir,
@@ -235,6 +234,9 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
     StringRef ModuleName, StringRef InPath, StringRef OutPath,
     bool SerializeDependencyHashes, bool TrackSystemDependencies,
     ModuleInterfaceLoaderOptions Opts);
+
+  std::string getUpToDateCompiledModuleForInterface(StringRef moduleName,
+                                                    StringRef interfacePath) override;
 };
 
 struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {

include/swift/Serialization/SerializedModuleLoader.h

@@ -200,6 +200,11 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   virtual Optional<ModuleDependencies> getModuleDependencies(
       StringRef moduleName, ModuleDependenciesCache &cache,
       InterfaceSubContextDelegate &delegate) override;
+
+  virtual std::string getUpToDateCompiledModuleForInterface(StringRef moduleName,
+                                                      StringRef interfacePath) {
+    return std::string();
+  }
 };
 
 /// Imports serialized Swift modules into an ASTContext.
@@ -445,12 +450,7 @@ class SerializedASTFile final : public LoadedFile {
   }
 };
 
-Optional<StringRef>
-computePrebuiltModulePath(ASTContext &ctx,
-                          StringRef interfacePath,
-                          StringRef prebuiltCacheDir,
-                          StringRef moduleName,
-                          llvm::SmallString<256> &scratch);
+
 } // end namespace swift
 
 #endif

lib/AST/ASTContext.cpp

@@ -263,6 +263,9 @@ struct ASTContext::Implementation {
   /// The module loader used to load Clang modules from DWARF.
   ClangModuleLoader *TheDWARFModuleLoader = nullptr;
 
+  /// The module loader used to load Swift textual interface.
+  ModuleLoader *TheModuleInterfaceLoader = nullptr;
+
   /// Map from Swift declarations to raw comments.
   llvm::DenseMap<const Decl *, RawComment> RawComments;
 
@@ -1450,14 +1453,15 @@ void ASTContext::addSearchPath(StringRef searchPath, bool isFramework,
 }
 
 void ASTContext::addModuleLoader(std::unique_ptr<ModuleLoader> loader,
-                                 bool IsClang, bool IsDwarf) {
+                                 bool IsClang, bool IsDwarf, bool IsInterface) {
   if (IsClang && !IsDwarf && !getImpl().TheClangModuleLoader)
     getImpl().TheClangModuleLoader =
         static_cast<ClangModuleLoader *>(loader.get());
   if (IsClang && IsDwarf && !getImpl().TheDWARFModuleLoader)
     getImpl().TheDWARFModuleLoader =
         static_cast<ClangModuleLoader *>(loader.get());
-
+  if (IsInterface && !getImpl().TheModuleInterfaceLoader)
+    getImpl().TheModuleInterfaceLoader = loader.get();
   getImpl().ModuleLoaders.push_back(std::move(loader));
 }
 
@@ -1532,6 +1536,10 @@ ClangModuleLoader *ASTContext::getDWARFModuleLoader() const {
   return getImpl().TheDWARFModuleLoader;
 }
 
+ModuleLoader *ASTContext::getModuleInterfaceLoader() const {
+  return getImpl().TheModuleInterfaceLoader;
+}
+
 ModuleDecl *ASTContext::getLoadedModule(
     ArrayRef<Located<Identifier>> ModulePath) const {
   assert(!ModulePath.empty());

lib/Frontend/Frontend.cpp

@@ -504,7 +504,7 @@ bool CompilerInstance::setUpModuleLoaders() {
         getDependencyTracker(), MLM, FEOpts.PreferInterfaceForModules,
         LoaderOpts,
         IgnoreSourceInfoFile);
-    Context->addModuleLoader(std::move(PIML));
+    Context->addModuleLoader(std::move(PIML), false, false, true);
   }
 
   std::unique_ptr<SerializedModuleLoader> SML =