[ossa][frontend] Separately namespace enable-ossa-modules in the prebuilt module cache so that the flag causes recompilation of imported resilient modules when the flag is enabled.

This will enable users to try out the '-enable-ossa-modules' flag if their
compiler supports it and get OSSA code on all inlinable code that they use. The
idea is that this is a nice way to stage this in and get more testing.

The specific implementation is that the module interface loader:

1. Knows if enable ossa modules is enabled not to search for any compiled
modules. We always rebuild from the interface file on the system.

2. Knows that if enable ossa modules is enabled to mixin a bit into the module
interface loader cache hash to ensure that we consider the specialized ossa
compiled modules to be different than the modules in that cache from the system.

This ensures that when said flag is enabled, the user transparently gets all
their code in OSSA form from transparent libraries.

Author: gottesmm

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -311,20 +311,40 @@ struct ModuleInterfaceLoaderOptions {
   ModuleInterfaceLoaderOptions() = default;
 };
 
+/// Strongly typed enum that represents if we require all SILModules to have
+/// OSSA modules emitted. This is implemented by incorporating this bit into the
+/// module cache hash.
+struct RequireOSSAModules_t {
+  enum ValueTy {
+    No = 0,
+    Yes = 1,
+  };
+
+  ValueTy value;
+
+  RequireOSSAModules_t(const SILOptions &opts)
+      : value(opts.EnableOSSAModules ? RequireOSSAModules_t::Yes
+                                     : RequireOSSAModules_t::No) {}
+
+  operator ValueTy() const { return value; }
+  explicit operator bool() const { return bool(value); }
+};
+
 class ModuleInterfaceCheckerImpl: public ModuleInterfaceChecker {
   friend class ModuleInterfaceLoader;
   ASTContext &Ctx;
   std::string CacheDir;
   std::string PrebuiltCacheDir;
   ModuleInterfaceLoaderOptions Opts;
+  RequireOSSAModules_t RequiresOSSAModules;
 
 public:
-  explicit ModuleInterfaceCheckerImpl(ASTContext &Ctx,
-                                      StringRef cacheDir,
+  explicit ModuleInterfaceCheckerImpl(ASTContext &Ctx, StringRef cacheDir,
                                       StringRef prebuiltCacheDir,
-                                      ModuleInterfaceLoaderOptions Opts)
-  : Ctx(Ctx), CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
-    Opts(Opts) {}
+                                      ModuleInterfaceLoaderOptions opts,
+                                      RequireOSSAModules_t requiresOSSAModules)
+      : Ctx(Ctx), CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
+        Opts(opts), RequiresOSSAModules(requiresOSSAModules) {}
 
   std::vector<std::string>
   getCompiledModuleCandidatesForInterface(StringRef moduleName,
@@ -390,13 +410,13 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
   ///
   /// A simplified version of the core logic in #openModuleFiles.
   static bool buildSwiftModuleFromSwiftInterface(
-    SourceManager &SourceMgr, DiagnosticEngine &Diags,
-    const SearchPathOptions &SearchPathOpts, const LangOptions &LangOpts,
-    const ClangImporterOptions &ClangOpts,
-    StringRef CacheDir, StringRef PrebuiltCacheDir,
-    StringRef ModuleName, StringRef InPath, StringRef OutPath,
-    bool SerializeDependencyHashes, bool TrackSystemDependencies,
-    ModuleInterfaceLoaderOptions Opts);
+      SourceManager &SourceMgr, DiagnosticEngine &Diags,
+      const SearchPathOptions &SearchPathOpts, const LangOptions &LangOpts,
+      const ClangImporterOptions &ClangOpts, StringRef CacheDir,
+      StringRef PrebuiltCacheDir, StringRef ModuleName, StringRef InPath,
+      StringRef OutPath, bool SerializeDependencyHashes,
+      bool TrackSystemDependencies, ModuleInterfaceLoaderOptions Opts,
+      RequireOSSAModules_t RequireOSSAModules);
 };
 
 struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
@@ -420,25 +440,24 @@ struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {
     }
     return Diags.diagnose(loc, ID, std::move(Args)...);
   }
-  void inheritOptionsForBuildingInterface(const SearchPathOptions &SearchPathOpts,
-                                          const LangOptions &LangOpts);
+  void
+  inheritOptionsForBuildingInterface(const SearchPathOptions &SearchPathOpts,
+                                     const LangOptions &LangOpts,
+                                     RequireOSSAModules_t requireOSSAModules);
   bool extractSwiftInterfaceVersionAndArgs(CompilerInvocation &subInvocation,
                                            SmallVectorImpl<const char *> &SubArgs,
                                            std::string &CompilerVersion,
                                            StringRef interfacePath,
                                            SourceLoc diagnosticLoc);
 public:
-  InterfaceSubContextDelegateImpl(SourceManager &SM,
-                                  DiagnosticEngine &Diags,
-                                  const SearchPathOptions &searchPathOpts,
-                                  const LangOptions &langOpts,
-                                  const ClangImporterOptions &clangImporterOpts,
-                                  ModuleInterfaceLoaderOptions LoaderOpts,
-                                  bool buildModuleCacheDirIfAbsent,
-                                  StringRef moduleCachePath,
-                                  StringRef prebuiltCachePath,
-                                  bool serializeDependencyHashes,
-                                  bool trackSystemDependencies);
+  InterfaceSubContextDelegateImpl(
+      SourceManager &SM, DiagnosticEngine &Diags,
+      const SearchPathOptions &searchPathOpts, const LangOptions &langOpts,
+      const ClangImporterOptions &clangImporterOpts,
+      ModuleInterfaceLoaderOptions LoaderOpts, bool buildModuleCacheDirIfAbsent,
+      StringRef moduleCachePath, StringRef prebuiltCachePath,
+      bool serializeDependencyHashes, bool trackSystemDependencies,
+      RequireOSSAModules_t requireOSSAModules);
   std::error_code runInSubContext(StringRef moduleName,
                                   StringRef interfacePath,
                                   StringRef outputPath,

lib/DependencyScan/ScanDependencies.cpp

@@ -1245,7 +1245,8 @@ swift::dependencies::performModuleScan(CompilerInstance &instance,
       /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
       FEOpts.PrebuiltModuleCachePath,
       FEOpts.SerializeModuleInterfaceDependencyHashes,
-      FEOpts.shouldTrackSystemDependencies());
+      FEOpts.shouldTrackSystemDependencies(),
+      RequireOSSAModules_t(instance.getSILOptions()));
 
   // Explore the dependencies of every module.
   for (unsigned currentModuleIdx = 0; currentModuleIdx < allModules.size();
@@ -1336,7 +1337,8 @@ swift::dependencies::performBatchModuleScan(
             /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
             FEOpts.PrebuiltModuleCachePath,
             FEOpts.SerializeModuleInterfaceDependencyHashes,
-            FEOpts.shouldTrackSystemDependencies());
+            FEOpts.shouldTrackSystemDependencies(),
+            RequireOSSAModules_t(instance.getSILOptions()));
         Optional<ModuleDependencies> rootDeps;
         if (isClang) {
           // Loading the clang module using Clang importer.
@@ -1403,7 +1405,8 @@ swift::dependencies::performBatchModulePrescan(
             /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
             FEOpts.PrebuiltModuleCachePath,
             FEOpts.SerializeModuleInterfaceDependencyHashes,
-            FEOpts.shouldTrackSystemDependencies());
+            FEOpts.shouldTrackSystemDependencies(),
+            RequireOSSAModules_t(instance.getSILOptions()));
         Optional<ModuleDependencies> rootDeps;
         if (isClang) {
           // Loading the clang module using Clang importer.

lib/Frontend/Frontend.cpp

@@ -524,8 +524,9 @@ bool CompilerInstance::setUpModuleLoaders() {
   auto &FEOpts = Invocation.getFrontendOptions();
   ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
   Context->addModuleInterfaceChecker(
-    std::make_unique<ModuleInterfaceCheckerImpl>(*Context, ModuleCachePath,
-      FEOpts.PrebuiltModuleCachePath, LoaderOpts));
+      std::make_unique<ModuleInterfaceCheckerImpl>(
+          *Context, ModuleCachePath, FEOpts.PrebuiltModuleCachePath, LoaderOpts,
+          RequireOSSAModules_t(Invocation.getSILOptions())));
   // If implicit modules are disabled, we need to install an explicit module
   // loader.
   bool ExplicitModuleBuild = Invocation.getFrontendOptions().DisableImplicitModules;
@@ -564,15 +565,14 @@ bool CompilerInstance::setUpModuleLoaders() {
                                                        ->getClangModuleLoader()->getClangInstance());
     auto &FEOpts = Invocation.getFrontendOptions();
     ModuleInterfaceLoaderOptions LoaderOpts(FEOpts);
-    InterfaceSubContextDelegateImpl ASTDelegate(Context->SourceMgr, Context->Diags,
-                                                Context->SearchPathOpts, Context->LangOpts,
-                                                Context->ClangImporterOpts,
-                                                LoaderOpts,
-                                                /*buildModuleCacheDirIfAbsent*/false,
-                                                ModuleCachePath,
-                                                FEOpts.PrebuiltModuleCachePath,
-                                                FEOpts.SerializeModuleInterfaceDependencyHashes,
-                                                FEOpts.shouldTrackSystemDependencies());
+    InterfaceSubContextDelegateImpl ASTDelegate(
+        Context->SourceMgr, Context->Diags, Context->SearchPathOpts,
+        Context->LangOpts, Context->ClangImporterOpts, LoaderOpts,
+        /*buildModuleCacheDirIfAbsent*/ false, ModuleCachePath,
+        FEOpts.PrebuiltModuleCachePath,
+        FEOpts.SerializeModuleInterfaceDependencyHashes,
+        FEOpts.shouldTrackSystemDependencies(),
+        RequireOSSAModules_t(Invocation.getSILOptions()));
     auto mainModuleName = Context->getIdentifier(FEOpts.ModuleName);
     std::unique_ptr<PlaceholderSwiftModuleScanner> PSMS =
       std::make_unique<PlaceholderSwiftModuleScanner>(*Context,