Serialize library level into .swiftmodule binary format

Add a LIBRARY_LEVEL record to the .swiftmodule options block so the
declared -library-level value survives across compilations. Without
this, imported modules have to always fell back to a path heuristic
that could only distinguish API vs SPI and never returned IPI.

rdar://174255626

Author: sepy97

include/swift/AST/Decl.h

@@ -778,7 +778,7 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
     HasLazyUnderlyingSubstitutions : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+8+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+1+8+1+2,
     /// If the module is compiled as static library.
     StaticLibrary : 1,
 
@@ -854,7 +854,10 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl>, public Swi
 
     /// Whether this module was compile with "aggressive" CMO i.e
     /// the flag: -cross-module-optimization.
-    AggressiveCMOEnabled : 1
+    AggressiveCMOEnabled : 1,
+
+    /// The stored library level from deserialized module data (LibraryLevel).
+    StoredLibraryLevel : 2
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,

include/swift/AST/Module.h

@@ -715,6 +715,15 @@ class ModuleDecl
   /// Distribution level of the module.
   LibraryLevel getLibraryLevel() const;
 
+  /// The stored library level from deserialized module data.
+  /// Returns LibraryLevel::Other if no level was stored.
+  LibraryLevel getStoredLibraryLevel() const {
+    return LibraryLevel(Bits.ModuleDecl.StoredLibraryLevel);
+  }
+  void setStoredLibraryLevel(LibraryLevel level) {
+    Bits.ModuleDecl.StoredLibraryLevel = unsigned(level);
+  }
+
   /// Returns true if this module was or is being compiled for testing.
   bool hasIncrementalInfo() const { return Bits.ModuleDecl.HasIncrementalInfo; }
   void setHasIncrementalInfo(bool enabled = true) {

include/swift/Serialization/Validation.h

@@ -16,6 +16,7 @@
 #include "swift/AST/Identifier.h"
 #include "swift/Basic/CXXStdlibKind.h"
 #include "swift/Basic/LLVM.h"
+#include "swift/Basic/LangOptions.h"
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/Version.h"
 #include "swift/Parse/ParseVersion.h"
@@ -153,6 +154,7 @@ class ExtendedValidationInfo {
     unsigned StrictMemorySafety: 1;
     unsigned DeferredCodeGen: 1;
     unsigned AggressiveCMOEnabled : 1;
+    unsigned LibraryLevel : 2;
   } Bits;
 
 public:
@@ -277,6 +279,13 @@ class ExtendedValidationInfo {
     Bits.AggressiveCMOEnabled = val;
   }
 
+  LibraryLevel getLibraryLevel() const {
+    return LibraryLevel(Bits.LibraryLevel);
+  }
+  void setLibraryLevel(LibraryLevel level) {
+    Bits.LibraryLevel = unsigned(level);
+  }
+
   bool hasCxxInteroperability() const { return Bits.HasCxxInteroperability; }
   void setHasCxxInteroperability(bool val) {
     Bits.HasCxxInteroperability = val;

lib/AST/Module.cpp

@@ -3331,8 +3331,13 @@ ModuleLibraryLevelRequest::evaluate(Evaluator &evaluator,
     return ctx.LangOpts.LibraryLevel;
 
   } else {
-    // Other Swift modules are SPI if they are from the PrivateFrameworks
-    // folder in the SDK.
+    // IPI is never returned by the path heuristic, so the stored value
+    // is the only way to detect it.
+    auto stored = module->getStoredLibraryLevel();
+    if (stored == LibraryLevel::IPI)
+      return stored;
+
+    // For API/SPI, use the path heuristic as before.
     auto modulePath = module->getModuleFilename();
     return fromPrivateFrameworks(modulePath) ?
       LibraryLevel::SPI : LibraryLevel::API;

lib/Serialization/ModuleFile.h

@@ -722,6 +722,9 @@ class ModuleFile
   /// (the flag -cross-module-optimization).
   bool isAggressiveCMOEnabled() const { return Core->isAggressiveCMOEnabled(); }
 
+  /// The library level of this module.
+  LibraryLevel getLibraryLevel() const { return Core->getLibraryLevel(); }
+
   /// Associates this module file with the AST node representing it.
   ///
   /// Checks that the file is compatible with the AST module it's being loaded

lib/Serialization/ModuleFileSharedCore.cpp

@@ -237,6 +237,12 @@ static bool readOptionsBlock(llvm::BitstreamCursor &cursor,
     case options_block::AGGRESSIVE_CMO:
       extendedInfo.setAggressiveCMOEnabled(true);
       break;
+    case options_block::LIBRARY_LEVEL: {
+      unsigned rawLevel;
+      options_block::LibraryLevelLayout::readRecord(scratch, rawLevel);
+      extendedInfo.setLibraryLevel(LibraryLevel(rawLevel));
+      break;
+    }
     default:
       // Unknown options record, possibly for use by a future version of the
       // module format.
@@ -1605,6 +1611,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
       Bits.StrictMemorySafety = extInfo.strictMemorySafety();
       Bits.DeferredCodeGen = extInfo.deferredCodeGen();
       Bits.AggressiveCMOEnabled = extInfo.isAggressiveCMOEnabled();
+      Bits.LibraryLevel = unsigned(extInfo.getLibraryLevel());
       MiscVersion = info.miscVersion;
       SDKVersion = info.sdkVersion;
       ModuleABIName = extInfo.getModuleABIName();

lib/Serialization/ModuleFileSharedCore.h

@@ -425,6 +425,9 @@ class ModuleFileSharedCore {
     /// Whether this module used deferred code generation.
     unsigned AggressiveCMOEnabled : 1;
 
+    /// Discriminator for library level (LibraryLevel enum).
+    unsigned LibraryLevel : 2;
+
     // Explicitly pad out to the next word boundary if neccessary.
   } Bits = {};
   static_assert(sizeof(ModuleBits) <= 8, "The bit set should be small");
@@ -702,6 +705,10 @@ class ModuleFileSharedCore {
 
   bool isAggressiveCMOEnabled() const { return Bits.AggressiveCMOEnabled; }
 
+  LibraryLevel getLibraryLevel() const {
+    return LibraryLevel(Bits.LibraryLevel);
+  }
+
   /// How should \p dependency be loaded for a transitive import via \c this?
   ///
   /// If \p importNonPublicDependencies, more transitive dependencies

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 = 990; // vtable conformance entries
+const uint16_t SWIFTMODULE_VERSION_MINOR = 991; // add LIBRARY_LEVEL to options_block
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -1004,6 +1004,7 @@ namespace options_block {
     DEFERRED_CODE_GEN,
     OSLOG_STRING_SECTION_NAME,
     AGGRESSIVE_CMO,
+    LIBRARY_LEVEL,
   };
 
   using SDKPathLayout = BCRecordLayout<
@@ -1126,6 +1127,11 @@ namespace options_block {
     SWIFT_INTERFACE_COMPILER_VERSION,
     BCBlob // version tuple
   >;
+
+  using LibraryLevelLayout = BCRecordLayout<
+    LIBRARY_LEVEL,
+    BCFixed<2>
+  >;
 }
 
 /// The record types within the input block.

lib/Serialization/ScanningLoaders.cpp

@@ -222,10 +222,23 @@ SwiftModuleScanner::scanInterfaceFile(Identifier moduleID,
         bool isStrictMemorySafety =
             llvm::find(ArgsRefs, "-strict-memory-safety") != ArgsRefs.end();
 
+        LibraryLevel libraryLevel = LibraryLevel::Other;
+        auto libLevelIt = llvm::find(ArgsRefs, "-library-level");
+        if (libLevelIt != ArgsRefs.end() &&
+            (libLevelIt + 1) != ArgsRefs.end()) {
+          libraryLevel = llvm::StringSwitch<LibraryLevel>(*(libLevelIt + 1))
+                             .Case("api", LibraryLevel::API)
+                             .Case("spi", LibraryLevel::SPI)
+                             .Case("ipi", LibraryLevel::IPI)
+                             .Default(LibraryLevel::Other);
+        }
+
         Result = ModuleDependencyInfo::forSwiftInterfaceModule(
             InPath, compiledCandidatesRefs, ArgsRefs, {}, {}, linkLibraries,
             isFramework, isStatic, isStrictMemorySafety, {},
             /*module-cache-key*/ "", UserModVer);
+        if (libraryLevel == LibraryLevel::IPI)
+          Result->setLibraryLevel(libraryLevel);
 
         // Walk the source file to find the import declarations.
         llvm::StringSet<> alreadyAddedModules;
@@ -282,8 +295,8 @@ SwiftModuleScanner::scanInterfaceFile(Identifier moduleID,
   if (code) {
     return code;
   }
-  // Compute library level based on the interface file path.
-  {
+  // Use path heuristic for API/SPI; IPI was already set from the flags above.
+  if (Result->getLibraryLevel() != LibraryLevel::IPI) {
     SmallString<256> modulePathBuf;
     StringRef modulePath = moduleInterfacePath.toStringRef(modulePathBuf);
     Result->setLibraryLevel(libraryLevelFromPath(
@@ -384,11 +397,17 @@ llvm::ErrorOr<ModuleDependencyInfo> SwiftModuleScanner::scanBinaryModuleFile(
                                     deps->ExecutablePath);
   }
 
-  // Compute library level based on the binary module path.
+  // Use the stored value only for IPI; path heuristic handles API/SPI as
+  // before.
   {
-    dependencies.setLibraryLevel(libraryLevelFromPath(
-        definingModulePath, Ctx.SearchPathOpts.getSDKPath(),
-        Ctx.LangOpts.Target));
+    auto storedLevel = loadedModuleFile->getLibraryLevel();
+    if (storedLevel == LibraryLevel::IPI) {
+      dependencies.setLibraryLevel(storedLevel);
+    } else {
+      dependencies.setLibraryLevel(libraryLevelFromPath(
+          definingModulePath, Ctx.SearchPathOpts.getSDKPath(),
+          Ctx.LangOpts.Target));
+    }
   }
 
   return std::move(dependencies);

lib/Serialization/Serialization.cpp

@@ -893,6 +893,7 @@ void Serializer::writeBlockInfoBlock() {
   BLOCK_RECORD(options_block, CXX_STDLIB_KIND);
   BLOCK_RECORD(options_block, PUBLIC_MODULE_NAME);
   BLOCK_RECORD(options_block, SWIFT_INTERFACE_COMPILER_VERSION);
+  BLOCK_RECORD(options_block, LIBRARY_LEVEL);
 
   BLOCK(INPUT_BLOCK);
   BLOCK_RECORD(input_block, IMPORTED_MODULE);
@@ -1225,6 +1226,10 @@ void Serializer::writeHeader() {
                            static_cast<uint8_t>(M->getCXXStdlibKind()));
       }
 
+      options_block::LibraryLevelLayout LibLevel(Out);
+      LibLevel.emit(ScratchRecord,
+                    unsigned(M->getASTContext().LangOpts.LibraryLevel));
+
       if (M->isAggressiveCMOEnabled()) {
         options_block::AggressiveCMOEnabledLayout AggressiveCMOEnabled(Out);
         AggressiveCMOEnabled.emit(ScratchRecord);