[Dependency Scanner] Refactor ModuleDependencies to represent binary-only Swift modules explicitly

This matches the behavior of the current client (`swift-driver`) and reduces ambiguity in how the nodes in the graph are to be treated. Swift dependencies with a textual interface, for example, must be built into a binary module by clients. Swift dependencies without a textual interface, with only a binary module, are to be used directly, without any up-to-date checks.

Note, this is distinct from Swift dependencies that have a textual interface, for which we also detect potential pre-build binary module candidates. Those are still reported in the `details` field of textual Swift dependencies as `prebuiltModuleCandidates`.

Author: artemcm

include/swift/AST/ModuleDependencies.h

@@ -34,7 +34,8 @@ class Identifier;
 
 /// Which kind of module dependencies we are looking for.
 enum class ModuleDependenciesKind : int8_t {
-  Swift,
+  SwiftTextual,
+  SwiftBinary,
   // Placeholder dependencies are a kind of dependencies used only by the
   // dependency scanner. They are swift modules that the scanner will not be
   // able to locate in its search paths and which are the responsibility of the
@@ -68,26 +69,22 @@ class ModuleDependenciesStorageBase {
 public:
   const ModuleDependenciesKind dependencyKind;
 
-  ModuleDependenciesStorageBase(ModuleDependenciesKind dependencyKind,
-                                const std::string &compiledModulePath)
-      : dependencyKind(dependencyKind),
-        compiledModulePath(compiledModulePath) { }
+  ModuleDependenciesStorageBase(ModuleDependenciesKind dependencyKind)
+      : dependencyKind(dependencyKind) { }
 
   virtual ModuleDependenciesStorageBase *clone() const = 0;
 
   virtual ~ModuleDependenciesStorageBase();
 
-  /// The path to the compiled module file.
-  const std::string compiledModulePath;
-
   /// The set of modules on which this module depends.
   std::vector<std::string> moduleDependencies;
 };
 
 /// Describes the dependencies of a Swift module.
 ///
 /// This class is mostly an implementation detail for \c ModuleDependencies.
-class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
+class SwiftTextualModuleDependenciesStorage :
+  public ModuleDependenciesStorageBase {
 public:
   /// The Swift interface file, if it can be used to generate the module file.
   const Optional<std::string> swiftInterfaceFile;
@@ -122,16 +119,14 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
   /// (Clang) modules on which the bridging header depends.
   std::vector<std::string> bridgingModuleDependencies;
 
-  SwiftModuleDependenciesStorage(
-      const std::string &compiledModulePath,
+  SwiftTextualModuleDependenciesStorage(
       const Optional<std::string> &swiftInterfaceFile,
       ArrayRef<std::string> compiledModuleCandidates,
       ArrayRef<StringRef> buildCommandLine,
       ArrayRef<StringRef> extraPCMArgs,
       StringRef contextHash,
       bool isFramework
-  ) : ModuleDependenciesStorageBase(ModuleDependenciesKind::Swift,
-                                    compiledModulePath),
+  ) : ModuleDependenciesStorageBase(ModuleDependenciesKind::SwiftTextual),
       swiftInterfaceFile(swiftInterfaceFile),
       compiledModuleCandidates(compiledModuleCandidates.begin(),
                                compiledModuleCandidates.end()),
@@ -140,11 +135,47 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
       contextHash(contextHash), isFramework(isFramework) { }
 
   ModuleDependenciesStorageBase *clone() const override {
-    return new SwiftModuleDependenciesStorage(*this);
+    return new SwiftTextualModuleDependenciesStorage(*this);
+  }
+
+  static bool classof(const ModuleDependenciesStorageBase *base) {
+    return base->dependencyKind == ModuleDependenciesKind::SwiftTextual;
   }
+};
+
+/// Describes the dependencies of a pre-built Swift module (with no .swiftinterface).
+///
+/// This class is mostly an implementation detail for \c ModuleDependencies.
+class SwiftBinaryModuleDependencyStorage : public ModuleDependenciesStorageBase {
+public:
+  SwiftBinaryModuleDependencyStorage(const std::string &compiledModulePath,
+                                     const std::string &moduleDocPath,
+                                     const std::string &sourceInfoPath,
+                                     const bool isFramework)
+      : ModuleDependenciesStorageBase(ModuleDependenciesKind::SwiftBinary),
+        compiledModulePath(compiledModulePath),
+        moduleDocPath(moduleDocPath),
+        sourceInfoPath(sourceInfoPath),
+        isFramework(isFramework) {}
+
+  ModuleDependenciesStorageBase *clone() const override {
+    return new SwiftBinaryModuleDependencyStorage(*this);
+  }
+
+  /// The path to the .swiftmodule file.
+  const std::string compiledModulePath;
+
+  /// The path to the .swiftModuleDoc file.
+  const std::string moduleDocPath;
+
+  /// The path to the .swiftSourceInfo file.
+  const std::string sourceInfoPath;
+
+  /// A flag that indicates this dependency is a framework
+  const bool isFramework;
 
   static bool classof(const ModuleDependenciesStorageBase *base) {
-    return base->dependencyKind == ModuleDependenciesKind::Swift;
+    return base->dependencyKind == ModuleDependenciesKind::SwiftBinary;
   }
 };
 
@@ -166,13 +197,11 @@ class ClangModuleDependenciesStorage : public ModuleDependenciesStorageBase {
   const std::vector<std::string> fileDependencies;
 
   ClangModuleDependenciesStorage(
-      const std::string &compiledModulePath,
       const std::string &moduleMapFile,
       const std::string &contextHash,
       const std::vector<std::string> &nonPathCommandLine,
       const std::vector<std::string> &fileDependencies
-  ) : ModuleDependenciesStorageBase(ModuleDependenciesKind::Clang,
-                                    compiledModulePath),
+  ) : ModuleDependenciesStorageBase(ModuleDependenciesKind::Clang),
       moduleMapFile(moduleMapFile),
       contextHash(contextHash),
       nonPathCommandLine(nonPathCommandLine),
@@ -190,20 +219,24 @@ class ClangModuleDependenciesStorage : public ModuleDependenciesStorageBase {
 /// Describes an placeholder Swift module dependency module stub.
 ///
 /// This class is mostly an implementation detail for \c ModuleDependencies.
-class PlaceholderSwiftModuleDependencyStorage : public ModuleDependenciesStorageBase {
+
+class SwiftPlaceholderModuleDependencyStorage : public ModuleDependenciesStorageBase {
 public:
-  PlaceholderSwiftModuleDependencyStorage(const std::string &compiledModulePath,
-                                       const std::string &moduleDocPath,
-                                       const std::string &sourceInfoPath)
-      : ModuleDependenciesStorageBase(ModuleDependenciesKind::SwiftPlaceholder,
-                                      compiledModulePath),
+  SwiftPlaceholderModuleDependencyStorage(const std::string &compiledModulePath,
+                                          const std::string &moduleDocPath,
+                                          const std::string &sourceInfoPath)
+      : ModuleDependenciesStorageBase(ModuleDependenciesKind::SwiftPlaceholder),
+        compiledModulePath(compiledModulePath),
         moduleDocPath(moduleDocPath),
         sourceInfoPath(sourceInfoPath) {}
 
   ModuleDependenciesStorageBase *clone() const override {
-    return new PlaceholderSwiftModuleDependencyStorage(*this);
+    return new SwiftPlaceholderModuleDependencyStorage(*this);
   }
 
+  /// The path to the .swiftmodule file.
+  const std::string compiledModulePath;
+
   /// The path to the .swiftModuleDoc file.
   const std::string moduleDocPath;
 
@@ -248,43 +281,41 @@ class ModuleDependencies {
       ArrayRef<StringRef> extraPCMArgs,
       StringRef contextHash,
       bool isFramework) {
-    std::string compiledModulePath;
     return ModuleDependencies(
-        std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, swiftInterfaceFile, compiledCandidates, buildCommands,
+        std::make_unique<SwiftTextualModuleDependenciesStorage>(
+          swiftInterfaceFile, compiledCandidates, buildCommands,
           extraPCMArgs, contextHash, isFramework));
   }
 
   /// Describe the module dependencies for a serialized or parsed Swift module.
-  static ModuleDependencies forSwiftModule(
-      const std::string &compiledModulePath, bool isFramework) {
+  static ModuleDependencies forSwiftBinaryModule(
+      const std::string &compiledModulePath,
+      const std::string &moduleDocPath,
+      const std::string &sourceInfoPath,
+      bool isFramework) {
     return ModuleDependencies(
-        std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, None, ArrayRef<std::string>(), ArrayRef<StringRef>(),
-          ArrayRef<StringRef>(), StringRef(), isFramework));
+        std::make_unique<SwiftBinaryModuleDependencyStorage>(
+          compiledModulePath, moduleDocPath, sourceInfoPath, isFramework));
   }
 
   /// Describe the main Swift module.
   static ModuleDependencies forMainSwiftModule(ArrayRef<StringRef> extraPCMArgs) {
-    std::string compiledModulePath;
     return ModuleDependencies(
-        std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, None, ArrayRef<std::string>(),
-          ArrayRef<StringRef>(), extraPCMArgs, StringRef(), false));
+        std::make_unique<SwiftTextualModuleDependenciesStorage>(
+          None, ArrayRef<std::string>(), ArrayRef<StringRef>(),
+          extraPCMArgs, StringRef(), false));
   }
 
   /// Describe the module dependencies for a Clang module that can be
   /// built from a module map and headers.
   static ModuleDependencies forClangModule(
-      const std::string &compiledModulePath,
       const std::string &moduleMapFile,
       const std::string &contextHash,
       const std::vector<std::string> &nonPathCommandLine,
       const std::vector<std::string> &fileDependencies) {
     return ModuleDependencies(
         std::make_unique<ClangModuleDependenciesStorage>(
-          compiledModulePath, moduleMapFile, contextHash, nonPathCommandLine,
-          fileDependencies));
+          moduleMapFile, contextHash, nonPathCommandLine, fileDependencies));
   }
 
   /// Describe a placeholder dependency swift module.
@@ -293,38 +324,45 @@ class ModuleDependencies {
       const std::string &moduleDocPath,
       const std::string &sourceInfoPath) {
     return ModuleDependencies(
-        std::make_unique<PlaceholderSwiftModuleDependencyStorage>(
+        std::make_unique<SwiftPlaceholderModuleDependencyStorage>(
           compiledModulePath, moduleDocPath, sourceInfoPath));
   }
 
-  /// Retrieve the path to the compiled module.
-  const std::string getCompiledModulePath() const {
-    return storage->compiledModulePath;
-  }
-
   /// Retrieve the module-level dependencies.
   ArrayRef<std::string> getModuleDependencies() const {
     return storage->moduleDependencies;
   }
 
-  /// Whether the dependencies are for a Swift module.
+  /// Whether the dependencies are for a Swift module: either Textual, Binary, or Placeholder.
   bool isSwiftModule() const;
 
+  /// Whether the dependencies are for a textual Swift module.
+  bool isSwiftTextualModule() const;
+
+  /// Whether the dependencies are for a binary Swift module.
+  bool isSwiftBinaryModule() const;
+
   /// Whether this represents a placeholder module stub
-  bool isPlaceholderSwiftModule() const;
+  bool isSwiftPlaceholderModule() const;
+
+  /// Whether the dependencies are for a Clang module.
+  bool isClangModule() const;
 
   ModuleDependenciesKind getKind() const {
     return storage->dependencyKind;
   }
   /// Retrieve the dependencies for a Swift module.
-  const SwiftModuleDependenciesStorage *getAsSwiftModule() const;
+  const SwiftTextualModuleDependenciesStorage *getAsSwiftTextualModule() const;
+
+  /// Retrieve the dependencies for a binary Swift module.
+  const SwiftBinaryModuleDependencyStorage *getAsSwiftBinaryModule() const;
 
   /// Retrieve the dependencies for a Clang module.
   const ClangModuleDependenciesStorage *getAsClangModule() const;
 
   /// Retrieve the dependencies for a placeholder dependency module stub.
-  const PlaceholderSwiftModuleDependencyStorage *
-  getAsPlaceholderDependencyModule() const;
+  const SwiftPlaceholderModuleDependencyStorage *
+    getAsPlaceholderDependencyModule() const;
 
   /// Add a dependency on the given module, if it was not already in the set.
   void addModuleDependency(StringRef module,
@@ -363,11 +401,14 @@ class ModuleDependenciesCache {
   /// encountered.
   std::vector<ModuleDependencyID> AllModules;
 
-  /// Dependencies for Swift modules that have already been computed.
-  llvm::StringMap<ModuleDependencies> SwiftModuleDependencies;
+  /// Dependencies for Textual Swift modules that have already been computed.
+  llvm::StringMap<ModuleDependencies> SwiftTextualModuleDependencies;
 
-  /// Dependencies for Swift placeholder dependency modules.
-  llvm::StringMap<ModuleDependencies> PlaceholderSwiftModuleDependencies;
+  /// Dependencies for Binary Swift modules that have already been computed.
+  llvm::StringMap<ModuleDependencies> SwiftBinaryModuleDependencies;
+
+  /// Dependencies for Swift placeholder dependency modules that have already been computed.
+  llvm::StringMap<ModuleDependencies> SwiftPlaceholderModuleDependencies;
 
   /// Dependencies for Clang modules that have already been computed.
   llvm::StringMap<ModuleDependencies> ClangModuleDependencies;
@@ -429,8 +470,7 @@ class ModuleDependenciesCache {
 
   /// Record dependencies for the given module.
   void recordDependencies(StringRef moduleName,
-                          ModuleDependencies dependencies,
-                          ModuleDependenciesKind kind);
+                          ModuleDependencies dependencies);
 
   /// Update stored dependencies for the given module.
   void updateDependencies(ModuleDependencyID moduleID,

include/swift/Serialization/ModuleDependencyScanner.h

@@ -40,18 +40,13 @@ namespace swift {
     public:
       Optional<ModuleDependencies> dependencies;
 
-      /// Describes the kind of dependencies this scanner is able to identify
-      ModuleDependenciesKind dependencyKind;
-
       ModuleDependencyScanner(
           ASTContext &ctx, ModuleLoadingMode LoadMode, Identifier moduleName,
           InterfaceSubContextDelegate &astDelegate,
-          ModuleDependenciesKind dependencyKind = ModuleDependenciesKind::Swift,
           ScannerKind kind = MDS_plain)
           : SerializedModuleLoaderBase(ctx, nullptr, LoadMode,
                                        /*IgnoreSwiftSourceInfoFile=*/true),
-            kind(kind), moduleName(moduleName), astDelegate(astDelegate),
-            dependencyKind(dependencyKind) {}
+            kind(kind), moduleName(moduleName), astDelegate(astDelegate) {}
 
       std::error_code findModuleFilesInDirectory(
           ImportPath::Element ModuleID,
@@ -60,7 +55,7 @@ namespace swift {
           std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer,
           std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer,
           std::unique_ptr<llvm::MemoryBuffer> *ModuleSourceInfoBuffer,
-                                                 bool IsFramework) override;
+          bool IsFramework) override;
 
       virtual void collectVisibleTopLevelModuleNames(
           SmallVectorImpl<Identifier> &names) const override {
@@ -106,7 +101,6 @@ namespace swift {
                                     StringRef PlaceholderDependencyModuleMap,
                                     InterfaceSubContextDelegate &astDelegate)
           : ModuleDependencyScanner(ctx, LoadMode, moduleName, astDelegate,
-                                    ModuleDependenciesKind::SwiftPlaceholder,
                                     MDS_placeholder) {
 
         // FIXME: Find a better place for this map to live, to avoid