ModuleInterface: reconstruct command-line arguments for building Swift module from interface explicitly

Author: nkcsgexi

include/swift/AST/ModuleDependencies.h

@@ -68,6 +68,13 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
   /// The Swift interface file, if it can be used to generate the module file.
   const Optional<std::string> swiftInterfaceFile;
 
+  /// The Swift frontend invocation arguments to build the Swift module from the
+  /// interface.
+  const std::vector<std::string> buildCommandLine;
+
+  /// The hash value that will be used for the generated module
+  const std::string contextHash;
+
   /// Bridging header file, if there is one.
   Optional<std::string> bridgingHeaderFile;
 
@@ -82,9 +89,13 @@ class SwiftModuleDependenciesStorage : public ModuleDependenciesStorageBase {
 
   SwiftModuleDependenciesStorage(
       const std::string &compiledModulePath,
-      const Optional<std::string> &swiftInterfaceFile
+      const Optional<std::string> &swiftInterfaceFile,
+      ArrayRef<StringRef> buildCommandLine,
+      StringRef contextHash
   ) : ModuleDependenciesStorageBase(/*isSwiftModule=*/true, compiledModulePath),
-      swiftInterfaceFile(swiftInterfaceFile) { }
+      swiftInterfaceFile(swiftInterfaceFile),
+      buildCommandLine(buildCommandLine.begin(), buildCommandLine.end()),
+      contextHash(contextHash) { }
 
   ModuleDependenciesStorageBase *clone() const override {
     return new SwiftModuleDependenciesStorage(*this);
@@ -162,18 +173,20 @@ class ModuleDependencies {
   /// built from a Swift interface file (\c .swiftinterface).
   static ModuleDependencies forSwiftInterface(
       const std::string &compiledModulePath,
-      const std::string &swiftInterfaceFile) {
+      const std::string &swiftInterfaceFile,
+      ArrayRef<StringRef> buildCommands,
+      StringRef contextHash) {
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, swiftInterfaceFile));
+          compiledModulePath, swiftInterfaceFile, buildCommands, contextHash));
   }
 
   /// Describe the module dependencies for a serialized or parsed Swift module.
   static ModuleDependencies forSwiftModule(
       const std::string &compiledModulePath) {
     return ModuleDependencies(
         std::make_unique<SwiftModuleDependenciesStorage>(
-          compiledModulePath, None));
+          compiledModulePath, None, ArrayRef<StringRef>(), StringRef()));
   }
 
   /// Describe the module dependencies for a Clang module that can be

include/swift/AST/ModuleLoader.h

@@ -89,6 +89,8 @@ class DependencyTracker {
 struct SubCompilerInstanceInfo {
   StringRef CompilerVersion;
   CompilerInstance* Instance;
+  StringRef Hash;
+  ArrayRef<StringRef> BuildArguments;
 };
 
 /// Abstract interface to run an action in a sub ASTContext.
@@ -97,7 +99,7 @@ struct InterfaceSubContextDelegate {
                                StringRef interfacePath,
                                StringRef outputPath,
                                SourceLoc diagLoc,
-                               llvm::function_ref<bool(ASTContext&)> action) = 0;
+  llvm::function_ref<bool(ASTContext&,ArrayRef<StringRef>, StringRef)> action) = 0;
   virtual bool runInSubCompilerInstance(StringRef moduleName,
                                         StringRef interfacePath,
                                         StringRef outputPath,

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -208,7 +208,11 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
 private:
   SourceManager &SM;
   DiagnosticEngine &Diags;
+  llvm::BumpPtrAllocator Allocator;
+  llvm::StringSaver ArgSaver;
+  std::vector<StringRef> GenericArgs;
   CompilerInvocation subInvocation;
+  std::vector<SupplementaryOutputPaths> ModuleOutputPaths;
 
   template<typename ...ArgTypes>
   InFlightDiagnostic diagnose(StringRef interfacePath,
@@ -222,45 +226,43 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
     }
     return Diags.diagnose(loc, ID, std::move(Args)...);
   }
-
-  bool extractSwiftInterfaceVersionAndArgs(llvm::StringSaver &SubArgSaver,
-                                           SmallVectorImpl<const char *> &SubArgs,
+  void inheritOptionsForBuildingInterface(const SearchPathOptions &SearchPathOpts,
+                                          const LangOptions &LangOpts);
+  bool extractSwiftInterfaceVersionAndArgs(SmallVectorImpl<const char *> &SubArgs,
                                            std::string &CompilerVersion,
                                            StringRef interfacePath,
                                            SourceLoc diagnosticLoc);
-  SubCompilerInstanceInfo createInstance(StringRef moduleName,
-                                         StringRef interfacePath,
-                                         StringRef outputPath,
-                                         SourceLoc diagLoc);
 public:
   InterfaceSubContextDelegateImpl(SourceManager &SM,
                                   DiagnosticEngine &Diags,
                                   const SearchPathOptions &searchPathOpts,
                                   const LangOptions &langOpts,
-                                  ClangModuleLoader *clangImporter = nullptr,
-                                  StringRef moduleCachePath = StringRef(),
-                                  StringRef prebuiltCachePath = StringRef(),
-                                  bool serializeDependencyHashes = false,
-                                  bool trackSystemDependencies = false,
-                                  bool remarkOnRebuildFromInterface = false,
-                                  bool disableInterfaceFileLock = false);
+                                  ClangModuleLoader *clangImporter,
+                                  bool buildModuleCacheDirIfAbsent,
+                                  StringRef moduleCachePath,
+                                  StringRef prebuiltCachePath,
+                                  bool serializeDependencyHashes,
+                                  bool trackSystemDependencies,
+                                  bool remarkOnRebuildFromInterface,
+                                  bool disableInterfaceFileLock);
   bool runInSubContext(StringRef moduleName,
                        StringRef interfacePath,
                        StringRef outputPath,
                        SourceLoc diagLoc,
-                       llvm::function_ref<bool(ASTContext&)> action) override;
+    llvm::function_ref<bool(ASTContext&, ArrayRef<StringRef>, StringRef)> action) override;
   bool runInSubCompilerInstance(StringRef moduleName,
                                 StringRef interfacePath,
                                 StringRef outputPath,
                                 SourceLoc diagLoc,
-                                llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) override;
+            llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) override;
 
   ~InterfaceSubContextDelegateImpl() = default;
 
   /// includes a hash of relevant key data.
-  void computeCachedOutputPath(StringRef moduleName,
-                               StringRef UseInterfacePath,
-                               llvm::SmallString<256> &OutPath);
+  StringRef computeCachedOutputPath(StringRef moduleName,
+                                    StringRef UseInterfacePath,
+                                    llvm::SmallString<256> &OutPath,
+                                    StringRef &CacheHash);
   std::string getCacheHash(StringRef useInterfacePath);
 };
 }

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -163,8 +163,10 @@ bool ModuleInterfaceBuilder::buildSwiftModuleInternal(
       llvm::RestorePrettyStackState(savedInnerPrettyStackState);
     };
 
-    SubError = subASTDelegate.runInSubCompilerInstance(moduleName, interfacePath,
-                                                       OutPath, diagnosticLoc,
+    SubError = subASTDelegate.runInSubCompilerInstance(moduleName,
+                                                       interfacePath,
+                                                       OutPath,
+                                                       diagnosticLoc,
                                            [&](SubCompilerInstanceInfo &info) {
     auto &SubInstance = *info.Instance;
     auto subInvocation = SubInstance.getInvocation();