[Serialization] Write in the swiftmodule if it's built from a swiftinterface

This information will allow us to distinguish swiftmodule built from
source vs swiftinterface.

Author: xymus

include/swift/AST/Decl.h

@@ -617,7 +617,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -632,6 +632,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     /// \sa ResilienceStrategy
     RawResilienceStrategy : 1,
 
+    /// Whether the module was rebuilt from a module interface instead of being
+    /// build from the full source.
+    IsBuiltFromInterface : 1,
+
     /// Whether all imports have been resolved. Used to detect circular imports.
     HasResolvedImports : 1,
 

include/swift/AST/Module.h

@@ -544,6 +544,15 @@ class ModuleDecl
     Bits.ModuleDecl.IsSystemModule = flag;
   }
 
+  /// Returns true if the module was rebuilt from a module interface instead
+  /// of being build from the full source.
+  bool isBuiltFromInterface() const {
+    return Bits.ModuleDecl.IsBuiltFromInterface;
+  }
+  void setIsBuiltFromInterface(bool flag = true) {
+    Bits.ModuleDecl.IsBuiltFromInterface = flag;
+  }
+
   /// Returns true if this module is a non-Swift module that was imported into
   /// Swift.
   ///

include/swift/Serialization/Validation.h

@@ -114,6 +114,7 @@ class ExtendedValidationInfo {
     unsigned IsTestable : 1;
     unsigned ResilienceStrategy : 2;
     unsigned IsImplicitDynamicEnabled : 1;
+    unsigned IsBuiltFromInterface : 1;
     unsigned IsAllowModuleWithCompilerErrorsEnabled : 1;
     unsigned IsConcurrencyChecked : 1;
   } Bits;
@@ -163,6 +164,10 @@ class ExtendedValidationInfo {
   void setResilienceStrategy(ResilienceStrategy resilience) {
     Bits.ResilienceStrategy = unsigned(resilience);
   }
+  bool isBuiltFromInterface() const { return Bits.IsBuiltFromInterface; }
+  void setIsBuiltFromInterface(bool val) {
+    Bits.IsBuiltFromInterface = val;
+  }
   bool isAllowModuleWithCompilerErrorsEnabled() {
     return Bits.IsAllowModuleWithCompilerErrorsEnabled;
   }

lib/Frontend/ModuleInterfaceBuilder.cpp

@@ -249,6 +249,7 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
 
   SILOptions &SILOpts = Invocation.getSILOptions();
   auto Mod = Instance.getMainModule();
+  Mod->setIsBuiltFromInterface(true);
   auto &TC = Instance.getSILTypes();
   auto SILMod = performASTLowering(Mod, TC, SILOpts);
   if (!SILMod) {

lib/Serialization/ModuleFile.h

@@ -517,6 +517,10 @@ class ModuleFile
     return ResilienceStrategy(Core->Bits.ResilienceStrategy);
   }
 
+  bool isBuiltFromInterface() const {
+    return Core->Bits.IsBuiltFromInterface;
+  }
+
   /// Whether this module is compiled with implicit dynamic.
   bool isImplicitDynamicEnabled() const {
     return Core->Bits.IsImplicitDynamicEnabled;

lib/Serialization/ModuleFileSharedCore.cpp

@@ -151,6 +151,9 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
       options_block::ResilienceStrategyLayout::readRecord(scratch, Strategy);
       extendedInfo.setResilienceStrategy(ResilienceStrategy(Strategy));
       break;
+    case options_block::IS_BUILT_FROM_INTERFACE:
+      extendedInfo.setIsBuiltFromInterface(true);
+      break;
     case options_block::IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED:
       extendedInfo.setAllowModuleWithCompilerErrorsEnabled(true);
       break;
@@ -1319,6 +1322,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
       Bits.IsTestable = extInfo.isTestable();
       Bits.ResilienceStrategy = unsigned(extInfo.getResilienceStrategy());
       Bits.IsImplicitDynamicEnabled = extInfo.isImplicitDynamicEnabled();
+      Bits.IsBuiltFromInterface = extInfo.isBuiltFromInterface();
       Bits.IsAllowModuleWithCompilerErrorsEnabled =
           extInfo.isAllowModuleWithCompilerErrorsEnabled();
       Bits.IsConcurrencyChecked = extInfo.isConcurrencyChecked();

lib/Serialization/ModuleFileSharedCore.h

@@ -347,6 +347,10 @@ class ModuleFileSharedCore {
     /// Discriminator for resilience strategy.
     unsigned ResilienceStrategy : 2;
 
+    /// Whether the module was rebuilt from a module interface instead of being
+    /// build from the full source.
+    unsigned IsBuiltFromInterface: 1;
+
     /// Whether this module is compiled with implicit dynamic.
     unsigned IsImplicitDynamicEnabled: 1;
 
@@ -357,7 +361,7 @@ class ModuleFileSharedCore {
     unsigned IsConcurrencyChecked: 1;
 
     // Explicitly pad out to the next word boundary.
-    unsigned : 5;
+    unsigned : 4;
   } Bits = {};
   static_assert(sizeof(ModuleBits) <= 8, "The bit set should be small");
 

lib/Serialization/ModuleFormat.h

@@ -58,7 +58,7 @@ const uint16_t SWIFTMODULE_VERSION_MAJOR = 0;
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
 /// Don't worry about adhering to the 80-column limit for this line.
-const uint16_t SWIFTMODULE_VERSION_MINOR = 718;  // element archetype
+const uint16_t SWIFTMODULE_VERSION_MINOR = 719;  // isBuiltFromInterface
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -826,6 +826,7 @@ namespace options_block {
     RESILIENCE_STRATEGY,
     ARE_PRIVATE_IMPORTS_ENABLED,
     IS_IMPLICIT_DYNAMIC_ENABLED,
+    IS_BUILT_FROM_INTERFACE,
     IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED,
     MODULE_ABI_NAME,
     IS_CONCURRENCY_CHECKED,
@@ -871,6 +872,10 @@ namespace options_block {
     BCFixed<2>
   >;
 
+  using IsBuiltFromInterfaceLayout = BCRecordLayout<
+    IS_BUILT_FROM_INTERFACE
+  >;
+
   using IsAllowModuleWithCompilerErrorsEnabledLayout = BCRecordLayout<
     IS_ALLOW_MODULE_WITH_COMPILER_ERRORS_ENABLED
   >;

lib/Serialization/Serialization.cpp

@@ -1049,6 +1049,11 @@ void Serializer::writeHeader(const SerializationOptions &options) {
         Strategy.emit(ScratchRecord, unsigned(M->getResilienceStrategy()));
       }
 
+      if (M->isBuiltFromInterface()) {
+        options_block::IsBuiltFromInterfaceLayout BuiltFromInterface(Out);
+        BuiltFromInterface.emit(ScratchRecord);
+      }
+
       if (allowCompilerErrors()) {
         options_block::IsAllowModuleWithCompilerErrorsEnabledLayout
             AllowErrors(Out);

lib/Serialization/SerializedModuleLoader.cpp

@@ -770,6 +770,8 @@ LoadedFile *SerializedModuleLoaderBase::loadAST(
       M.setImplicitDynamicEnabled();
     if (loadedModuleFile->hasIncrementalInfo())
       M.setHasIncrementalInfo();
+    if (loadedModuleFile->isBuiltFromInterface())
+      M.setIsBuiltFromInterface();
     if (!loadedModuleFile->getModuleABIName().empty())
       M.setABIName(Ctx.getIdentifier(loadedModuleFile->getModuleABIName()));
     if (loadedModuleFile->isConcurrencyChecked())