ClangImporter: refactor ClangImporterOptions to be ASTContext-owned. NFC

We need ClangImporterOptions to be persistent for several scenarios: (1)
when creating a sub-ASTContext to build Swift modules from interfaces; and
(2) when creating a new Clang instance to invoke Clang dependencies scanner.

This change is NFC.

Author: nkcsgexi

include/swift/AST/ASTContext.h

@@ -214,7 +214,9 @@ class ASTContext final {
   void operator=(const ASTContext&) = delete;
 
   ASTContext(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
-             SearchPathOptions &SearchPathOpts, SourceManager &SourceMgr,
+             SearchPathOptions &SearchPathOpts,
+             ClangImporterOptions &ClangImporterOpts,
+             SourceManager &SourceMgr,
              DiagnosticEngine &Diags);
 
 public:
@@ -228,6 +230,7 @@ class ASTContext final {
 
   static ASTContext *get(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
                          SearchPathOptions &SearchPathOpts,
+                         ClangImporterOptions &ClangImporterOpts,
                          SourceManager &SourceMgr, DiagnosticEngine &Diags);
   ~ASTContext();
 
@@ -246,6 +249,9 @@ class ASTContext final {
   /// The search path options used by this AST context.
   SearchPathOptions &SearchPathOpts;
 
+  /// The clang importer options used by this AST context.
+  ClangImporterOptions &ClangImporterOpts;
+
   /// The source manager object.
   SourceManager &SourceMgr;
 

include/swift/Basic/LangOptions.h

@@ -577,6 +577,115 @@ namespace swift {
     /// parameters of closures.
     bool EnableOneWayClosureParameters = false;
   };
+
+  /// Options for controlling the behavior of the Clang importer.
+  class ClangImporterOptions final {
+  public:
+    /// The module cache path which the Clang importer should use.
+    std::string ModuleCachePath;
+
+    /// Extra arguments which should be passed to the Clang importer.
+    std::vector<std::string> ExtraArgs;
+
+    /// A directory for overriding Clang's resource directory.
+    std::string OverrideResourceDir;
+
+    /// The target CPU to compile for.
+    ///
+    /// Equivalent to Clang's -mcpu=.
+    std::string TargetCPU;
+
+    /// The path to which we should store indexing data, if any.
+    std::string IndexStorePath;
+
+    /// The bridging header or PCH that will be imported.
+    std::string BridgingHeader;
+
+    /// When automatically generating a precompiled header from the bridging
+    /// header, place it in this directory.
+    std::string PrecompiledHeaderOutputDir;
+
+    /// The optimizaton setting.  This doesn't typically matter for
+    /// import, but it can affect Clang's IR generation of static functions.
+    std::string Optimization;
+
+    /// Disable validating the persistent PCH.
+    bool PCHDisableValidation = false;
+
+    /// \see Mode
+    enum class Modes : uint8_t {
+      /// Set up Clang for importing modules into Swift and generating IR from
+      /// Swift code.
+      Normal,
+      /// Set up Clang for backend compilation only.
+      EmbedBitcode,
+      /// Set up Clang to emit a precompiled module from a C/Objective-C module
+      /// map or dump debugging info about a precompiled module.
+      PrecompiledModule
+    };
+
+    /// Controls how Clang is initially set up.
+    Modes Mode = Modes::Normal;
+
+    /// When set, preserves more information during import.
+    ///
+    /// Also \em disables some information that is only needed for object file
+    /// generation.
+    bool DetailedPreprocessingRecord = false;
+
+    /// If true, Clang diagnostics will be dumped to stderr using Clang's
+    /// diagnostic printer as well as being passed to Swift's diagnostic engine.
+    bool DumpClangDiagnostics = false;
+
+    /// If true, forward declarations will be imported using unavailable types
+    /// instead of dropped altogether when possible.
+    bool ImportForwardDeclarations = false;
+
+    /// Whether to use the import as member inference system
+    ///
+    /// When importing a global, try to infer whether we can import it as a
+    /// member of some type instead. This includes inits, computed properties,
+    /// and methods.
+    bool InferImportAsMember = false;
+
+    /// If true ignore the swift bridged attribute.
+    bool DisableSwiftBridgeAttr = false;
+
+    /// When set, don't look for or load overlays.
+    bool DisableOverlayModules = false;
+
+    /// When set, don't enforce warnings with -Werror.
+    bool DebuggerSupport = false;
+
+    /// When set, ClangImporter is disabled, and all requests go to the
+    /// DWARFImporter delegate.
+    bool DisableSourceImport = false;
+
+    /// When set, use ExtraArgs alone to configure clang instance because ExtraArgs
+    /// contains the full option set.
+    bool ExtraArgsOnly = false;
+
+    /// Return a hash code of any components from these options that should
+    /// contribute to a Swift Bridging PCH hash.
+    llvm::hash_code getPCHHashComponents() const {
+      using llvm::hash_combine;
+      using llvm::hash_combine_range;
+
+      return hash_combine(ModuleCachePath,
+                          hash_combine_range(ExtraArgs.begin(), ExtraArgs.end()),
+                          OverrideResourceDir,
+                          TargetCPU,
+                          BridgingHeader,
+                          PrecompiledHeaderOutputDir,
+                          static_cast<uint8_t>(Mode),
+                          DetailedPreprocessingRecord,
+                          ImportForwardDeclarations,
+                          InferImportAsMember,
+                          DisableSwiftBridgeAttr,
+                          DisableOverlayModules);
+    }
+  };
+
 } // end namespace swift
 
 #endif // SWIFT_BASIC_LANGOPTIONS_H

include/swift/ClangImporter/ClangImporter.h

@@ -115,7 +115,7 @@ class ClangImporter final : public ClangModuleLoader {
 private:
   Implementation &Impl;
 
-  ClangImporter(ASTContext &ctx, const ClangImporterOptions &clangImporterOpts,
+  ClangImporter(ASTContext &ctx,
                 DependencyTracker *tracker,
                 DWARFImporterDelegate *dwarfImporterDelegate);
 
@@ -137,8 +137,6 @@ class ClangImporter final : public ClangModuleLoader {
   /// \param ctx The ASTContext into which the module will be imported.
   /// The ASTContext's SearchPathOptions will be used for the Clang importer.
   ///
-  /// \param importerOpts The options to use for the Clang importer.
-  ///
   /// \param swiftPCHHash A hash of Swift's various options in a compiler
   /// invocation, used to create a unique Bridging PCH if requested.
   ///
@@ -150,12 +148,12 @@ class ClangImporter final : public ClangModuleLoader {
   /// \returns a new Clang module importer, or null (with a diagnostic) if
   /// an error occurred.
   static std::unique_ptr<ClangImporter>
-  create(ASTContext &ctx, const ClangImporterOptions &importerOpts,
+  create(ASTContext &ctx,
          std::string swiftPCHHash = "", DependencyTracker *tracker = nullptr,
          DWARFImporterDelegate *dwarfImporterDelegate = nullptr);
 
   static std::vector<std::string>
-  getClangArguments(ASTContext &ctx, const ClangImporterOptions &importerOpts);
+  getClangArguments(ASTContext &ctx);
 
   static std::unique_ptr<clang::CompilerInvocation>
   createClangInvocation(ClangImporter *importer,

include/swift/ClangImporter/ClangImporterOptions.h

@@ -30,7 +30,6 @@
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/ClangImporter/ClangImporter.h"
-#include "swift/ClangImporter/ClangImporterOptions.h"
 #include "swift/Frontend/DiagnosticVerifier.h"
 #include "swift/Frontend/FrontendOptions.h"
 #include "swift/Frontend/ModuleInterfaceSupport.h"

include/swift/Frontend/Frontend.h

@@ -548,6 +548,7 @@ void ASTContext::operator delete(void *Data) throw() {
 ASTContext *ASTContext::get(LangOptions &langOpts,
                             TypeCheckerOptions &typeckOpts,
                             SearchPathOptions &SearchPathOpts,
+                            ClangImporterOptions &ClangImporterOpts,
                             SourceManager &SourceMgr,
                             DiagnosticEngine &Diags) {
   // If more than two data structures are concatentated, then the aggregate
@@ -561,15 +562,19 @@ ASTContext *ASTContext::get(LangOptions &langOpts,
       llvm::alignAddr(impl, llvm::Align(alignof(Implementation))));
   new (impl) Implementation();
   return new (mem)
-      ASTContext(langOpts, typeckOpts, SearchPathOpts, SourceMgr, Diags);
+      ASTContext(langOpts, typeckOpts, SearchPathOpts, ClangImporterOpts,
+                 SourceMgr, Diags);
 }
 
 ASTContext::ASTContext(LangOptions &langOpts, TypeCheckerOptions &typeckOpts,
                        SearchPathOptions &SearchPathOpts,
+                       ClangImporterOptions &ClangImporterOpts,
                        SourceManager &SourceMgr, DiagnosticEngine &Diags)
   : LangOpts(langOpts),
     TypeCheckerOpts(typeckOpts),
-    SearchPathOpts(SearchPathOpts), SourceMgr(SourceMgr), Diags(Diags),
+    SearchPathOpts(SearchPathOpts),
+    ClangImporterOpts(ClangImporterOpts),
+    SourceMgr(SourceMgr), Diags(Diags),
     evaluator(Diags, langOpts),
     TheBuiltinModule(createBuiltinModule(*this)),
     StdlibModuleName(getIdentifier(STDLIB_NAME)),