ModuleInterface: refactor compiler instance configuration to a standalone delegate class. NFC

nkcsgexi · nkcsgexi · commit 3952fd5bf7a5 · 2020-05-12T16:19:27.000-07:00
Module interface builder used to maintain a separate compiler instance for
building Swift modules. The configuration of this compiler instance is also
useful for dependencies scanner because it needs to emit front-end compiler invocation
for building Swift modules explicitly.

This patch refactor the configuration out to a delegate class, and the
delegate class is also used by the dependency scanner.
diff --git a/include/swift/AST/ASTContext.h b/include/swift/AST/ASTContext.h
@@ -121,7 +121,7 @@ namespace swift {
   class UnifiedStatsReporter;
   class IndexSubset;
   struct SILAutoDiffDerivativeFunctionKey;
-  struct SubASTContextDelegate;
+  struct InterfaceSubContextDelegate;
 
   enum class KnownProtocolKind : uint8_t;
 
@@ -721,7 +721,7 @@ class ASTContext final {
       StringRef moduleName,
       bool isUnderlyingClangModule,
       ModuleDependenciesCache &cache,
-      SubASTContextDelegate &delegate);
+      InterfaceSubContextDelegate &delegate);
 
   /// Load extensions to the given nominal type from the external
   /// module loaders.
diff --git a/include/swift/AST/ModuleLoader.h b/include/swift/AST/ModuleLoader.h
@@ -48,6 +48,7 @@ class ModuleDependenciesCache;
 class NominalTypeDecl;
 class SourceFile;
 class TypeDecl;
+class CompilerInstance;
 
 enum class KnownProtocolKind : uint8_t;
 
@@ -85,13 +86,25 @@ class DependencyTracker {
   std::shared_ptr<clang::DependencyCollector> getClangCollector();
 };
 
+struct SubCompilerInstanceInfo {
+  StringRef CompilerVersion;
+  CompilerInstance* Instance;
+};
+
 /// Abstract interface to run an action in a sub ASTContext.
-struct SubASTContextDelegate {
-  virtual bool runInSubContext(ASTContext &ctx, StringRef interfacePath,
-    llvm::function_ref<bool(ASTContext&)> action) {
-    llvm_unreachable("function should be overriden");
-  }
-  virtual ~SubASTContextDelegate() = default;
+struct InterfaceSubContextDelegate {
+  virtual bool runInSubContext(StringRef moduleName,
+                               StringRef interfacePath,
+                               StringRef outputPath,
+                               SourceLoc diagLoc,
+                               llvm::function_ref<bool(ASTContext&)> action) = 0;
+  virtual bool runInSubCompilerInstance(StringRef moduleName,
+                                        StringRef interfacePath,
+                                        StringRef outputPath,
+                                        SourceLoc diagLoc,
+                    llvm::function_ref<bool(SubCompilerInstanceInfo&)> action) = 0;
+
+  virtual ~InterfaceSubContextDelegate() = default;
 };
 
 /// Abstract interface that loads named modules into the AST.
@@ -196,7 +209,8 @@ class ModuleLoader {
   /// if no such module exists.
   virtual Optional<ModuleDependencies> getModuleDependencies(
       StringRef moduleName,
-      ModuleDependenciesCache &cache, SubASTContextDelegate &delegate) = 0;
+      ModuleDependenciesCache &cache,
+      InterfaceSubContextDelegate &delegate) = 0;
 };
 
 } // namespace swift
diff --git a/include/swift/ClangImporter/ClangImporter.h b/include/swift/ClangImporter/ClangImporter.h
@@ -371,7 +371,7 @@ class ClangImporter final : public ClangModuleLoader {
 
   Optional<ModuleDependencies> getModuleDependencies(
       StringRef moduleName, ModuleDependenciesCache &cache,
-      SubASTContextDelegate &delegate) override;
+      InterfaceSubContextDelegate &delegate) override;
 
   /// Add dependency information for the bridging header.
   ///
diff --git a/include/swift/Frontend/FrontendInputsAndOutputs.h b/include/swift/Frontend/FrontendInputsAndOutputs.h
@@ -173,7 +173,7 @@ class FrontendInputsAndOutputs {
 
 private:
   friend class ArgsToFrontendOptionsConverter;
-  friend class ModuleInterfaceBuilder;
+  friend struct InterfaceSubContextDelegateImpl;
   void setMainAndSupplementaryOutputs(
       ArrayRef<std::string> outputFiles,
       ArrayRef<SupplementaryOutputPaths> supplementaryOutputs);
diff --git a/include/swift/Frontend/ModuleInterfaceLoader.h b/include/swift/Frontend/ModuleInterfaceLoader.h
@@ -108,6 +108,7 @@
 #define SWIFT_FRONTEND_MODULEINTERFACELOADER_H
 
 #include "swift/Basic/LLVM.h"
+#include "swift/Frontend/Frontend.h"
 #include "swift/Frontend/ModuleInterfaceSupport.h"
 #include "swift/Serialization/SerializedModuleLoader.h"
 #include "llvm/Support/StringSaver.h"
@@ -203,18 +204,65 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
 std::string
 getModuleCachePathFromClang(const clang::CompilerInstance &Instance);
 
-bool extractSwiftInterfaceVersionAndArgs(SourceManager &SM,
-                                         DiagnosticEngine &Diags,
-                                         StringRef InterfacePath,
-                                         version::Version &Vers,
-                                         StringRef &CompilerVersion,
-                                         llvm::StringSaver &SubArgSaver,
-                                         SmallVectorImpl<const char *> &SubArgs,
-                                         SourceLoc diagnosticLoc = SourceLoc());
-
-void inheritOptionsForBuildingInterface(CompilerInvocation &Invok,
-                                        const SearchPathOptions &SearchPathOpts,
-                                        const LangOptions &LangOpts);
+struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
+private:
+  SourceManager &SM;
+  DiagnosticEngine &Diags;
+  CompilerInvocation subInvocation;
+
+  template<typename ...ArgTypes>
+  InFlightDiagnostic diagnose(StringRef interfacePath,
+                              SourceLoc diagnosticLoc,
+                              Diag<ArgTypes...> ID,
+                        typename detail::PassArgument<ArgTypes>::type... Args) {
+    SourceLoc loc = diagnosticLoc;
+    if (diagnosticLoc.isInvalid()) {
+      // Diagnose this inside the interface file, if possible.
+      loc = SM.getLocFromExternalSource(interfacePath, 1, 1);
+    }
+    return Diags.diagnose(loc, ID, std::move(Args)...);
+  }
+
+  bool extractSwiftInterfaceVersionAndArgs(llvm::StringSaver &SubArgSaver,
+                                           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);
+  bool runInSubContext(StringRef moduleName,
+                       StringRef interfacePath,
+                       StringRef outputPath,
+                       SourceLoc diagLoc,
+                       llvm::function_ref<bool(ASTContext&)> action) override;
+  bool runInSubCompilerInstance(StringRef moduleName,
+                                StringRef interfacePath,
+                                StringRef outputPath,
+                                SourceLoc diagLoc,
+                                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);
+  std::string getCacheHash(StringRef useInterfacePath);
+};
 }
 
 #endif
diff --git a/include/swift/Sema/SourceLoader.h b/include/swift/Sema/SourceLoader.h
@@ -94,7 +94,7 @@ class SourceLoader : public ModuleLoader {
 
   Optional<ModuleDependencies> getModuleDependencies(
       StringRef moduleName, ModuleDependenciesCache &cache,
-      SubASTContextDelegate &delegate) override {
+      InterfaceSubContextDelegate &delegate) override {
     // FIXME: Implement?
     return None;
   }
diff --git a/include/swift/Serialization/SerializedModuleLoader.h b/include/swift/Serialization/SerializedModuleLoader.h
@@ -195,7 +195,7 @@ class SerializedModuleLoaderBase : public ModuleLoader {
 
   virtual Optional<ModuleDependencies> getModuleDependencies(
       StringRef moduleName, ModuleDependenciesCache &cache,
-      SubASTContextDelegate &delegate) override;
+      InterfaceSubContextDelegate &delegate) override;
 };
 
 /// Imports serialized Swift modules into an ASTContext.
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -1463,7 +1463,7 @@ void ASTContext::addModuleLoader(std::unique_ptr<ModuleLoader> loader,
 
 Optional<ModuleDependencies> ASTContext::getModuleDependencies(
     StringRef moduleName, bool isUnderlyingClangModule,
-    ModuleDependenciesCache &cache, SubASTContextDelegate &delegate) {
+    ModuleDependenciesCache &cache, InterfaceSubContextDelegate &delegate) {
   for (auto &loader : getImpl().ModuleLoaders) {
     if (isUnderlyingClangModule &&
         loader.get() != getImpl().TheClangModuleLoader)
diff --git a/lib/ClangImporter/ClangImporter.cpp b/lib/ClangImporter/ClangImporter.cpp
@@ -803,7 +803,7 @@ bool ClangImporter::canReadPCH(StringRef PCHFilename) {
   CI.setInvocation(std::move(invocation));
   CI.setTarget(&Impl.Instance->getTarget());
   CI.setDiagnostics(
-      &*CompilerInstance::createDiagnostics(new clang::DiagnosticOptions()));
+      &*clang::CompilerInstance::createDiagnostics(new clang::DiagnosticOptions()));
 
   // Note: Reusing the file manager is safe; this is a component that's already
   // reused when building PCM files for the module cache.
diff --git a/lib/ClangImporter/ClangModuleDependencyScanner.cpp b/lib/ClangImporter/ClangModuleDependencyScanner.cpp
@@ -225,7 +225,7 @@ static void recordModuleDependencies(
 
 Optional<ModuleDependencies> ClangImporter::getModuleDependencies(
     StringRef moduleName, ModuleDependenciesCache &cache,
-    SubASTContextDelegate &delegate) {
+    InterfaceSubContextDelegate &delegate) {
   // Check whether there is already a cached result.
   if (auto found = cache.findDependencies(
           moduleName, ModuleDependenciesKind::Clang))
diff --git a/lib/Frontend/ModuleInterfaceBuilder.cpp b/lib/Frontend/ModuleInterfaceBuilder.cpp
diff --git a/lib/Frontend/ModuleInterfaceBuilder.h b/lib/Frontend/ModuleInterfaceBuilder.h
diff --git a/lib/Frontend/ModuleInterfaceLoader.cpp b/lib/Frontend/ModuleInterfaceLoader.cpp
diff --git a/lib/FrontendTool/ScanDependencies.cpp b/lib/FrontendTool/ScanDependencies.cpp
diff --git a/lib/Serialization/ModuleDependencyScanner.cpp b/lib/Serialization/ModuleDependencyScanner.cpp

Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ class SourceLoader : public ModuleLoader {`
`94`	`94`
`95`	`95`	`Optional<ModuleDependencies> getModuleDependencies(`
`96`	`96`	`StringRef moduleName, ModuleDependenciesCache &cache,`
`97`		`- SubASTContextDelegate &delegate) override {`
	`97`	`+ InterfaceSubContextDelegate &delegate) override {`
`98`	`98`	`// FIXME: Implement?`
`99`	`99`	`return None;`
`100`	`100`	`}`