[Serialization] Minor ModuleFile/ModuleFileSharedCore improvements

include/swift/Serialization/Validation.h

@@ -177,9 +177,8 @@ ValidationInfo validateSerializedAST(
 /// - \p ModuleName is the name used to refer to the module in diagnostics.
 void diagnoseSerializedASTLoadFailure(
     ASTContext &Ctx, SourceLoc diagLoc, const ValidationInfo &loadInfo,
-    const ExtendedValidationInfo &extendedInfo, StringRef moduleBufferID,
-    StringRef moduleDocBufferID, ModuleFile *loadedModuleFile,
-    Identifier ModuleName);
+    StringRef moduleBufferID, StringRef moduleDocBufferID,
+    ModuleFile *loadedModuleFile, Identifier ModuleName);
 
 } // end namespace serialization
 } // end namespace swift

lib/Serialization/ModuleFile.cpp

@@ -349,15 +349,13 @@ ModuleFile::getModuleName(ASTContext &Ctx, StringRef modulePath,
     llvm::MemoryBuffer::getMemBuffer(llvm::MemoryBufferRef(*moduleBuf.get()),
     /*RequiresNullTerminator=*/false);
   std::shared_ptr<const ModuleFileSharedCore> loadedModuleFile;
-  ExtendedValidationInfo ExtInfo;
   bool isFramework = false;
   serialization::ValidationInfo loadInfo =
      ModuleFileSharedCore::load(modulePath.str(),
                       std::move(newBuf),
                       nullptr,
                       nullptr,
-                      /*isFramework*/isFramework, loadedModuleFile,
-                      &ExtInfo);
+                      /*isFramework*/isFramework, loadedModuleFile);
   Name = loadedModuleFile->Name.str();
   return std::move(moduleBuf.get());
 }

lib/Serialization/ModuleFile.h

@@ -438,11 +438,31 @@ class ModuleFile
     return Core->CompatibilityVersion;
   }
 
+  /// Whether this module is compiled with `-enable-private-imports`.
+  bool arePrivateImportsEnabled() const {
+    return Core->Bits.ArePrivateImportsEnabled;
+  }
+
   /// Is this module file actually a .sib file? .sib files are serialized SIL at
   /// arbitrary granularity and arbitrary stage; unlike serialized Swift
   /// modules, which are assumed to contain canonical SIL for an entire module.
   bool isSIB() const {
-    return Core->IsSIB;
+    return Core->Bits.IsSIB;
+  }
+
+  /// Whether this module file is compiled with '-enable-testing'.
+  bool isTestable() const {
+    return Core->Bits.IsTestable;
+  }
+
+  /// Whether the module is resilient. ('-enable-library-evolution')
+  ResilienceStrategy getResilienceStrategy() const {
+    return ResilienceStrategy(Core->Bits.ResilienceStrategy);
+  }
+
+  /// Whether this module is compiled with implicit dynamic.
+  bool isImplicitDynamicEnabled() const {
+    return Core->Bits.IsImplicitDynamicEnabled;
   }
 
   /// Associates this module file with the AST node representing it.

lib/Serialization/ModuleFileSharedCore.cpp

@@ -1087,8 +1087,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
     std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,
     std::unique_ptr<llvm::MemoryBuffer> moduleDocInputBuffer,
     std::unique_ptr<llvm::MemoryBuffer> moduleSourceInfoInputBuffer,
-    bool isFramework, serialization::ValidationInfo &info,
-    serialization::ExtendedValidationInfo *extInfo)
+    bool isFramework, serialization::ValidationInfo &info)
     : ModuleInputBuffer(std::move(moduleInputBuffer)),
       ModuleDocInputBuffer(std::move(moduleDocInputBuffer)),
       ModuleSourceInfoInputBuffer(std::move(moduleSourceInfoInputBuffer)) {
@@ -1134,18 +1133,23 @@ ModuleFileSharedCore::ModuleFileSharedCore(
         return;
       }
 
+      ExtendedValidationInfo extInfo;
       info = validateControlBlock(cursor, scratch,
                                   {SWIFTMODULE_VERSION_MAJOR,
                                    SWIFTMODULE_VERSION_MINOR},
-                                  extInfo);
+                                  &extInfo);
       if (info.status != Status::Valid) {
         error(info.status);
         return;
       }
       Name = info.name;
       TargetTriple = info.targetTriple;
       CompatibilityVersion = info.compatibilityVersion;
-      IsSIB = extInfo->isSIB();
+      Bits.ArePrivateImportsEnabled = extInfo.arePrivateImportsEnabled();
+      Bits.IsSIB = extInfo.isSIB();
+      Bits.IsTestable = extInfo.isTestable();
+      Bits.ResilienceStrategy = unsigned(extInfo.getResilienceStrategy());
+      Bits.IsImplicitDynamicEnabled = extInfo.isImplicitDynamicEnabled();
       MiscVersion = info.miscVersion;
 
       hasValidControlBlock = true;

lib/Serialization/ModuleFileSharedCore.h

@@ -69,11 +69,6 @@ class ModuleFileSharedCore {
   /// The data blob containing all of the module's identifiers.
   StringRef IdentifierData;
 
-  /// Is this module file actually a .sib file? .sib files are serialized SIL at
-  /// arbitrary granularity and arbitrary stage; unlike serialized Swift
-  /// modules, which are assumed to contain canonical SIL for an entire module.
-  bool IsSIB = false;
-
   // Full blob from the misc. version field of the metadata block. This should
   // include the version string of the compiler that built the module.
   StringRef MiscVersion;
@@ -307,6 +302,21 @@ class ModuleFileSharedCore {
     /// Whether an error has been detected setting up this module file.
     unsigned HasError : 1;
 
+    /// Whether this module is `-enable-private-imports`.
+    unsigned ArePrivateImportsEnabled : 1;
+
+    /// Whether this module file is actually a .sib file.
+    unsigned IsSIB: 1;
+
+    /// Whether this module file is compiled with '-enable-testing'.
+    unsigned IsTestable : 1;
+
+    /// Discriminator for resilience strategy.
+    unsigned ResilienceStrategy : 2;
+
+    /// Whether this module is compiled with implicit dynamic.
+    unsigned IsImplicitDynamicEnabled: 1;
+
     // Explicitly pad out to the next word boundary.
     unsigned : 0;
   } Bits = {};
@@ -326,8 +336,7 @@ class ModuleFileSharedCore {
   ModuleFileSharedCore(std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,
                  std::unique_ptr<llvm::MemoryBuffer> moduleDocInputBuffer,
                  std::unique_ptr<llvm::MemoryBuffer> moduleSourceInfoInputBuffer,
-                 bool isFramework, serialization::ValidationInfo &info,
-                 serialization::ExtendedValidationInfo *extInfo);
+                 bool isFramework, serialization::ValidationInfo &info);
 
   /// Change the status of the current module.
   Status error(Status issue) {
@@ -455,12 +464,12 @@ class ModuleFileSharedCore {
        std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,
        std::unique_ptr<llvm::MemoryBuffer> moduleDocInputBuffer,
        std::unique_ptr<llvm::MemoryBuffer> moduleSourceInfoInputBuffer,
-       bool isFramework, std::shared_ptr<const ModuleFileSharedCore> &theModule,
-       serialization::ExtendedValidationInfo *extInfo = nullptr) {
+       bool isFramework,
+       std::shared_ptr<const ModuleFileSharedCore> &theModule) {
     serialization::ValidationInfo info;
     auto *core = new ModuleFileSharedCore(
         std::move(moduleInputBuffer), std::move(moduleDocInputBuffer),
-        std::move(moduleSourceInfoInputBuffer), isFramework, info, extInfo);
+        std::move(moduleSourceInfoInputBuffer), isFramework, info);
     if (!moduleInterfacePath.empty()) {
       ArrayRef<char> path;
       core->allocateBuffer(path, moduleInterfacePath);

lib/Serialization/SerializedModuleLoader.cpp

@@ -387,14 +387,12 @@ llvm::ErrorOr<ModuleDependencies> SerializedModuleLoaderBase::scanModuleFile(
   // Load the module file without validation.
   std::shared_ptr<const ModuleFileSharedCore> loadedModuleFile;
   bool isFramework = false;
-  serialization::ExtendedValidationInfo extInfo;
   serialization::ValidationInfo loadInfo =
       ModuleFileSharedCore::load(modulePath.str(),
                        std::move(moduleBuf.get()),
                        nullptr,
                        nullptr,
-                       isFramework, loadedModuleFile,
-                       &extInfo);
+                       isFramework, loadedModuleFile);
 
   // Map the set of dependencies over to the "module dependencies".
   auto dependencies = ModuleDependencies::forSwiftModule(modulePath.str(), isFramework);
@@ -695,28 +693,26 @@ FileUnit *SerializedModuleLoaderBase::loadAST(
     return nullptr;
   }
 
-  serialization::ExtendedValidationInfo extendedInfo;
   std::unique_ptr<ModuleFile> loadedModuleFile;
   std::shared_ptr<const ModuleFileSharedCore> loadedModuleFileCore;
   serialization::ValidationInfo loadInfo =
       ModuleFileSharedCore::load(moduleInterfacePath,
                        std::move(moduleInputBuffer),
                        std::move(moduleDocInputBuffer),
                        std::move(moduleSourceInfoInputBuffer),
-                       isFramework, loadedModuleFileCore,
-                       &extendedInfo);
+                       isFramework, loadedModuleFileCore);
   if (loadInfo.status == serialization::Status::Valid) {
     loadedModuleFile =
         std::make_unique<ModuleFile>(std::move(loadedModuleFileCore));
-    M.setResilienceStrategy(extendedInfo.getResilienceStrategy());
+    M.setResilienceStrategy(loadedModuleFile->getResilienceStrategy());
 
     // We've loaded the file. Now try to bring it into the AST.
     auto fileUnit = new (Ctx) SerializedASTFile(M, *loadedModuleFile);
-    if (extendedInfo.isTestable())
+    if (loadedModuleFile->isTestable())
       M.setTestingEnabled();
-    if (extendedInfo.arePrivateImportsEnabled())
+    if (loadedModuleFile->arePrivateImportsEnabled())
       M.setPrivateImportsEnabled();
-    if (extendedInfo.isImplicitDynamicEnabled())
+    if (loadedModuleFile->isImplicitDynamicEnabled())
       M.setImplicitDynamicEnabled();
 
     auto diagLocOrInvalid = diagLoc.getValueOr(SourceLoc());
@@ -744,7 +740,7 @@ FileUnit *SerializedModuleLoaderBase::loadAST(
 
   if (diagLoc)
     serialization::diagnoseSerializedASTLoadFailure(
-        Ctx, *diagLoc, loadInfo, extendedInfo, moduleBufferID,
+        Ctx, *diagLoc, loadInfo, moduleBufferID,
         moduleDocBufferID, loadedModuleFile.get(), M.getName());
 
   // Even though the module failed to load, it's possible its contents include
@@ -761,7 +757,6 @@ FileUnit *SerializedModuleLoaderBase::loadAST(
 void swift::serialization::diagnoseSerializedASTLoadFailure(
     ASTContext &Ctx, SourceLoc diagLoc,
     const serialization::ValidationInfo &loadInfo,
-    const serialization::ExtendedValidationInfo &extendedInfo,
     StringRef moduleBufferID, StringRef moduleDocBufferID,
     ModuleFile *loadedModuleFile, Identifier ModuleName) {
   auto diagnoseDifferentLanguageVersion = [&](StringRef shortVersion) -> bool {