Serialization: Reject swiftmodules built with a different C++ interop mode

xymus · xymus · commit 51041e4657bc · 2025-07-22T14:34:23.000-07:00
Intro an option to reject swiftmodules built in a different C++ interop
mode. This rejects non-library-evolution swiftmodules that are
incompabtible with a fatal error, and forces rebuilding
library-evolution enabled modules from the swiftinterface. This applies
to both local and distributed modules.

This option is behind the env var
SWIFT_ENABLE_SWIFTMODULE_PER_CXX_INTEROP for now.

Allow for modules under the resource dir to be be rebuilt from
swiftinterface on a C++ interop mismatch.
diff --git a/include/swift/AST/DiagnosticsSema.def b/include/swift/AST/DiagnosticsSema.def
@@ -949,6 +949,11 @@ ERROR(serialization_target_incompatible,Fatal,
 ERROR(serialization_sdk_mismatch,Fatal,
       "cannot load module %0 built with SDK '%1' when using SDK '%2': %3",
       (Identifier, StringRef, StringRef, StringRef))
+ERROR(serialization_cxx_interop_mismatch,Fatal,
+      "cannot load module %0 built with the C++ interop "
+      "%select{enabled|disabled}1 from a module where it's "
+      "%select{disabled|enabled}1",
+      (Identifier, bool))
 ERROR(serialization_target_incompatible_repl,none,
       "module %0 was created for incompatible target %1: %2",
       (Identifier, StringRef, StringRef))
diff --git a/include/swift/Serialization/SerializationOptions.h b/include/swift/Serialization/SerializationOptions.h
@@ -163,6 +163,7 @@ class SerializationOptions {
   bool HermeticSealAtLink = false;
   bool EmbeddedSwiftModule = false;
   bool IsOSSA = false;
+  bool IsCXXInterop = false;
   bool SkipNonExportableDecls = false;
   bool ExplicitModuleBuild = false;
   bool EnableSerializationRemarks = false;
diff --git a/include/swift/Serialization/SerializedModuleLoader.h b/include/swift/Serialization/SerializedModuleLoader.h
@@ -186,6 +186,7 @@ class SerializedModuleLoaderBase : public ModuleLoader {
                                         bool isRequiredOSSAModules,
                                         StringRef SDKName,
                                         const llvm::Triple &target,
+                                        bool isRequiredCXXInterop,
                                         StringRef packageName,
                                         llvm::vfs::FileSystem *fileSystem,
                                         PathObfuscator &recoverer);
diff --git a/include/swift/Serialization/Validation.h b/include/swift/Serialization/Validation.h
@@ -86,6 +86,9 @@ enum class Status {
   /// The module file was built with a different SDK than the one in use
   /// to build the client.
   SDKMismatch,
+
+  /// The module was built with a different C++ interop mode.
+  CxxInteropMismatch,
 };
 
 /// Returns the string for the Status enum.
@@ -302,7 +305,7 @@ struct SearchPath {
 /// input files the module depends on, if present in INPUT_BLOCK.
 ValidationInfo validateSerializedAST(
     StringRef data, bool requiresOSSAModules,
-    StringRef requiredSDK,
+    StringRef requiredSDK, bool requiresCXXInterop,
     ExtendedValidationInfo *extendedInfo = nullptr,
     SmallVectorImpl<SerializationOptions::FileDependency> *dependencies =
         nullptr,
diff --git a/lib/ASTSectionImporter/ASTSectionImporter.cpp b/lib/ASTSectionImporter/ASTSectionImporter.cpp
@@ -59,7 +59,7 @@ swift::parseASTSection(MemoryBufferSerializedModuleLoader &Loader,
   while (!buf.empty()) {
     auto info = serialization::validateSerializedAST(
         buf, Loader.isRequiredOSSAModules(),
-        /*requiredSDK*/StringRef());
+        /*requiredSDK*/StringRef(), /*requiresCXXInterop*/false);
 
     assert(info.name.size() < (2 << 10) && "name failed sanity check");
 
diff --git a/lib/Frontend/CompilerInvocation.cpp b/lib/Frontend/CompilerInvocation.cpp
@@ -4168,6 +4168,7 @@ CompilerInvocation::loadFromSerializedAST(StringRef data) {
         data,
         getSILOptions().EnableOSSAModules,
         LangOpts.SDKName,
+        LangOpts.EnableCXXInterop,
         &extendedInfo);
 
   if (info.status != serialization::Status::Valid)
@@ -4206,6 +4207,7 @@ CompilerInvocation::setUpInputForSILTool(
       fileBufOrErr.get()->getBuffer(),
       getSILOptions().EnableOSSAModules,
       LangOpts.SDKName,
+      LangOpts.EnableCXXInterop,
       &extendedInfo);
   bool hasSerializedAST = result.status == serialization::Status::Valid;
 
diff --git a/lib/Frontend/Frontend.cpp b/lib/Frontend/Frontend.cpp
@@ -280,6 +280,8 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(
   }
 
   serializationOpts.IsOSSA = getSILOptions().EnableOSSAModules;
+  serializationOpts.IsCXXInterop =
+      getLangOptions().EnableCXXInterop;
 
   serializationOpts.SkipNonExportableDecls =
       getLangOptions().SkipNonExportableDecls;
diff --git a/lib/Frontend/ModuleInterfaceBuilder.cpp b/lib/Frontend/ModuleInterfaceBuilder.cpp
@@ -307,6 +307,8 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(
     SerializationOpts.Dependencies = Deps;
   }
   SerializationOpts.IsOSSA = SILOpts.EnableOSSAModules;
+  SerializationOpts.IsCXXInterop =
+    Instance.getASTContext().LangOpts.EnableCXXInterop;
 
   SILMod->setSerializeSILAction([&]() {
     // We don't want to serialize module docs in the cache -- they
diff --git a/lib/Frontend/ModuleInterfaceLoader.cpp b/lib/Frontend/ModuleInterfaceLoader.cpp
@@ -214,10 +214,12 @@ namespace path = llvm::sys::path;
 
 static bool serializedASTLooksValid(const llvm::MemoryBuffer &buf,
                                     bool requiresOSSAModules,
-                                    StringRef requiredSDK) {
+                                    StringRef requiredSDK,
+                                    bool requiresCXXInterop) {
   auto VI = serialization::validateSerializedAST(buf.getBuffer(),
                                                  requiresOSSAModules,
-                                                 requiredSDK);
+                                                 requiredSDK,
+                                                 requiresCXXInterop);
   return VI.status == serialization::Status::Valid;
 }
 
@@ -461,7 +463,8 @@ class UpToDateModuleCheker {
     LLVM_DEBUG(llvm::dbgs() << "Validating deps of " << path << "\n");
     auto validationInfo = serialization::validateSerializedAST(
         buf.getBuffer(), requiresOSSAModules,
-        ctx.LangOpts.SDKName, /*ExtendedValidationInfo=*/nullptr, &allDeps);
+        ctx.LangOpts.SDKName, ctx.LangOpts.EnableCXXInterop,
+        /*ExtendedValidationInfo=*/nullptr, &allDeps);
 
     if (validationInfo.status != serialization::Status::Valid) {
       rebuildInfo.setSerializationStatus(path, validationInfo.status);
@@ -623,7 +626,8 @@ class ModuleInterfaceLoaderImpl {
 
     auto looksValid = serializedASTLooksValid(*modBuf.get(),
                                               requiresOSSAModules,
-                                              ctx.LangOpts.SDKName);
+                                              ctx.LangOpts.SDKName,
+                                              ctx.LangOpts.EnableCXXInterop);
     if (!looksValid)
       return false;
 
@@ -936,6 +940,9 @@ class ModuleInterfaceLoaderImpl {
                    rebuildInfo.getOrInsertCandidateModule(adjacentMod)
                            .serializationStatus !=
                        serialization::Status::SDKMismatch &&
+                   rebuildInfo.getOrInsertCandidateModule(adjacentMod)
+                           .serializationStatus !=
+                       serialization::Status::CxxInteropMismatch &&
                    // FIXME (meg-gupta): We need to support recompilation of
                    // modules in the resource directory if the mismatch is due
                    // to importing a non-ossa module to an ossa module. This is
@@ -2404,7 +2411,8 @@ bool ExplicitSwiftModuleLoader::canImportModule(
   auto metaData = serialization::validateSerializedAST(
       (*moduleBuf)->getBuffer(),
       Ctx.SILOpts.EnableOSSAModules,
-      Ctx.LangOpts.SDKName);
+      Ctx.LangOpts.SDKName,
+      Ctx.LangOpts.EnableCXXInterop);
   versionInfo->setVersion(metaData.userModuleVersion,
                           ModuleVersionSourceKind::SwiftBinaryModule);
   return true;
@@ -2758,7 +2766,7 @@ bool ExplicitCASModuleLoader::canImportModule(
   }
   auto metaData = serialization::validateSerializedAST(
       moduleBuf->getBuffer(), Ctx.SILOpts.EnableOSSAModules,
-      Ctx.LangOpts.SDKName);
+      Ctx.LangOpts.SDKName, Ctx.LangOpts.EnableCXXInterop);
   versionInfo->setVersion(metaData.userModuleVersion,
                           ModuleVersionSourceKind::SwiftBinaryModule);
   return true;
diff --git a/lib/FrontendTool/FrontendTool.cpp b/lib/FrontendTool/FrontendTool.cpp
@@ -1455,6 +1455,7 @@ static bool serializeSIB(SILModule *SM, const PrimarySpecificPaths &PSPs,
   serializationOpts.SerializeAllSIL = true;
   serializationOpts.IsSIB = true;
   serializationOpts.IsOSSA = Context.SILOpts.EnableOSSAModules;
+  serializationOpts.IsCXXInterop = Context.LangOpts.EnableCXXInterop;
 
   symbolgraphgen::SymbolGraphOptions symbolGraphOptions;
 
diff --git a/lib/Serialization/ModuleFile.cpp b/lib/Serialization/ModuleFile.cpp
@@ -428,6 +428,7 @@ ModuleFile::getModuleName(ASTContext &Ctx, StringRef modulePath,
       "", "", std::move(newBuf), nullptr, nullptr,
       /*isFramework=*/isFramework, Ctx.SILOpts.EnableOSSAModules,
       Ctx.LangOpts.SDKName, Ctx.LangOpts.Target,
+      Ctx.LangOpts.EnableCXXInterop,
       Ctx.SearchPathOpts.DeserializedPathRecoverer, loadedModuleFile);
   Name = loadedModuleFile->Name.str();
   return std::move(moduleBuf.get());
diff --git a/lib/Serialization/ModuleFileSharedCore.cpp b/lib/Serialization/ModuleFileSharedCore.cpp
@@ -243,6 +243,7 @@ static ValidationInfo validateControlBlock(
     bool requiresRevisionMatch,
     StringRef requiredSDK,
     std::optional<llvm::Triple> target,
+    bool requiresCxxInterop,
     ExtendedValidationInfo *extendedInfo,
     PathObfuscator &pathRecoverer) {
   // The control block is malformed until we've at least read a major version
@@ -487,6 +488,17 @@ static ValidationInfo validateControlBlock(
         result.status = Status::NotInOSSA;
       break;
     }
+    case control_block::IS_CXX_INTEROP: {
+      static const char* enableCxxInteropRestriction =
+        ::getenv("SWIFT_ENABLE_SWIFTMODULE_PER_CXX_INTEROP");
+      if (!enableCxxInteropRestriction)
+        break;
+
+      auto isCxxInteropEnabled = scratch[0];
+      if (isCxxInteropEnabled != requiresCxxInterop)
+        result.status = Status::CxxInteropMismatch;
+      break;
+    }
     default:
       // Unknown metadata record, possibly for use by a future version of the
       // module format.
@@ -601,6 +613,7 @@ std::string serialization::StatusToString(Status S) {
   case Status::TargetIncompatible: return "TargetIncompatible";
   case Status::TargetTooNew: return "TargetTooNew";
   case Status::SDKMismatch: return "SDKMismatch";
+  case Status::CxxInteropMismatch: return "CxxInteropMismatch";
   }
   llvm_unreachable("The switch should cover all cases");
 }
@@ -613,7 +626,7 @@ bool serialization::isSerializedAST(StringRef data) {
 
 ValidationInfo serialization::validateSerializedAST(
     StringRef data, bool requiresOSSAModules,
-    StringRef requiredSDK,
+    StringRef requiredSDK, bool requiresCXXInterop,
     ExtendedValidationInfo *extendedInfo,
     SmallVectorImpl<SerializationOptions::FileDependency> *dependencies,
     SmallVectorImpl<SearchPath> *searchPaths,
@@ -661,6 +674,7 @@ ValidationInfo serialization::validateSerializedAST(
           requiresOSSAModules,
           /*requiresRevisionMatch=*/true,
           requiredSDK, target,
+          requiresCXXInterop,
           extendedInfo, localObfuscator);
       if (result.status != Status::Valid)
         return result;
@@ -1213,6 +1227,7 @@ bool ModuleFileSharedCore::readModuleDocIfPresent(PathObfuscator &pathRecoverer)
           RequiresOSSAModules,
           /*requiresRevisionMatch*/false,
           /*requiredSDK*/StringRef(), /*target*/std::nullopt,
+          RequiresCXXInterop,
           /*extendedInfo*/nullptr, pathRecoverer);
       if (info.status != Status::Valid)
         return false;
@@ -1359,6 +1374,7 @@ bool ModuleFileSharedCore::readModuleSourceInfoIfPresent(PathObfuscator &pathRec
           RequiresOSSAModules,
           /*requiresRevisionMatch*/false,
           /*requiredSDK*/StringRef(), /*target*/std::nullopt,
+          RequiresCXXInterop,
           /*extendedInfo*/nullptr, pathRecoverer);
       if (info.status != Status::Valid)
         return false;
@@ -1437,11 +1453,13 @@ ModuleFileSharedCore::ModuleFileSharedCore(
     bool requiresOSSAModules,
     StringRef requiredSDK,
     std::optional<llvm::Triple> target,
+    bool requiresCXXInterop,
     serialization::ValidationInfo &info, PathObfuscator &pathRecoverer)
     : ModuleInputBuffer(std::move(moduleInputBuffer)),
       ModuleDocInputBuffer(std::move(moduleDocInputBuffer)),
       ModuleSourceInfoInputBuffer(std::move(moduleSourceInfoInputBuffer)),
-      RequiresOSSAModules(requiresOSSAModules) {
+      RequiresOSSAModules(requiresOSSAModules),
+      RequiresCXXInterop(requiresCXXInterop) {
   assert(!hasError());
   Bits.IsFramework = isFramework;
 
@@ -1490,6 +1508,7 @@ ModuleFileSharedCore::ModuleFileSharedCore(
           {SWIFTMODULE_VERSION_MAJOR, SWIFTMODULE_VERSION_MINOR},
           RequiresOSSAModules,
           /*requiresRevisionMatch=*/true, requiredSDK, target,
+          RequiresCXXInterop,
           &extInfo, pathRecoverer);
       if (info.status != Status::Valid) {
         error(info.status);
diff --git a/lib/Serialization/ModuleFileSharedCore.h b/lib/Serialization/ModuleFileSharedCore.h
@@ -117,6 +117,9 @@ class ModuleFileSharedCore {
   /// \c true if this module was compiled with -enable-ossa-modules.
   bool RequiresOSSAModules;
 
+  /// \c true if this module was compiled with C++ interoperability enabled.
+  bool RequiresCXXInterop;
+
   /// An array of module names that are allowed to import this one.
   ArrayRef<StringRef> AllowableClientNames;
 
@@ -445,6 +448,7 @@ class ModuleFileSharedCore {
       bool requiresOSSAModules,
       StringRef requiredSDK,
       std::optional<llvm::Triple> target,
+      bool requiresCXXInterop,
       serialization::ValidationInfo &info, PathObfuscator &pathRecoverer);
 
   /// Change the status of the current module.
@@ -576,6 +580,8 @@ class ModuleFileSharedCore {
   /// to ensure that the loaded module was built with a compatible SDK.
   /// \param target The target triple of the current compilation for
   /// validating that the module we are attempting to load is compatible.
+  /// \param requiresCXXInterop True if the current compilation uses the C++
+  /// interop, requires modules to have a matching setting.
   /// \param[out] theModule The loaded module.
   /// \returns Whether the module was successfully loaded, or what went wrong
   ///          if it was not.
@@ -586,14 +592,14 @@ class ModuleFileSharedCore {
        std::unique_ptr<llvm::MemoryBuffer> moduleSourceInfoInputBuffer,
        bool isFramework, bool requiresOSSAModules,
        StringRef requiredSDK, std::optional<llvm::Triple> target,
-       PathObfuscator &pathRecoverer,
+       bool requiresCXXInterop, PathObfuscator &pathRecoverer,
        std::shared_ptr<const ModuleFileSharedCore> &theModule) {
     serialization::ValidationInfo info;
     auto *core = new ModuleFileSharedCore(
         std::move(moduleInputBuffer), std::move(moduleDocInputBuffer),
         std::move(moduleSourceInfoInputBuffer), isFramework,
-        requiresOSSAModules, requiredSDK, target, info,
-        pathRecoverer);
+        requiresOSSAModules, requiredSDK, target, requiresCXXInterop,
+        info, pathRecoverer);
     if (!moduleInterfacePath.empty()) {
       ArrayRef<char> path;
       core->allocateBuffer(path, moduleInterfacePath);
diff --git a/lib/Serialization/ModuleFormat.h b/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 = 956; // nonisolated(nonsending) isolation was moved
+const uint16_t SWIFTMODULE_VERSION_MINOR = 957; // C++ interop mismatch
 
 /// A standard hash seed used for all string hashes in a serialized module.
 ///
@@ -902,6 +902,7 @@ namespace control_block {
     ALLOWABLE_CLIENT_NAME,
     CHANNEL,
     SDK_VERSION,
+    IS_CXX_INTEROP,
   };
 
   using MetadataLayout = BCRecordLayout<
@@ -956,6 +957,11 @@ namespace control_block {
     SDK_VERSION,
     BCBlob
   >;
+
+  using IsCXXInteropLayout = BCRecordLayout<
+    IS_CXX_INTEROP,
+    BCFixed<1>
+  >;
 }
 
 /// The record types within the options block (a sub-block of the control
diff --git a/lib/Serialization/ScanningLoaders.cpp b/lib/Serialization/ScanningLoaders.cpp
@@ -239,6 +239,7 @@ SwiftModuleScanner::scanInterfaceFile(Identifier moduleID,
                 getMatchingPackageOnlyImportsOfModule(
                     *adjacentBinaryModule, isFramework, isRequiredOSSAModules(),
                     Ctx.LangOpts.SDKName, Ctx.LangOpts.Target,
+                    Ctx.LangOpts.EnableCXXInterop,
                     ScannerPackageName, Ctx.SourceMgr.getFileSystem().get(),
                     Ctx.SearchPathOpts.DeserializedPathRecoverer);
 
@@ -280,6 +281,7 @@ llvm::ErrorOr<ModuleDependencyInfo> SwiftModuleScanner::scanBinaryModuleFile(
   serialization::ValidationInfo loadInfo = ModuleFileSharedCore::load(
       "", "", std::move(moduleBuf.get()), nullptr, nullptr, isFramework,
       isRequiredOSSAModules(), Ctx.LangOpts.SDKName, Ctx.LangOpts.Target,
+      Ctx.LangOpts.EnableCXXInterop,
       Ctx.SearchPathOpts.DeserializedPathRecoverer, loadedModuleFile);
 
   if (Ctx.SearchPathOpts.ScannerModuleValidation) {
diff --git a/lib/Serialization/Serialization.cpp b/lib/Serialization/Serialization.cpp
@@ -1014,6 +1014,7 @@ void Serializer::writeHeader() {
     control_block::ChannelLayout Channel(Out);
     control_block::IsOSSALayout IsOSSA(Out);
     control_block::AllowableClientLayout Allowable(Out);
+    control_block::IsCXXInteropLayout IsCXXInterop(Out);
 
     // Write module 'real name', which can be different from 'name'
     // in case module aliasing is used (-module-alias flag)
@@ -1071,6 +1072,8 @@ void Serializer::writeHeader() {
 
     IsOSSA.emit(ScratchRecord, Options.IsOSSA);
 
+    IsCXXInterop.emit(ScratchRecord, Options.IsCXXInterop);
+
     {
       llvm::BCBlockRAII restoreBlock(Out, OPTIONS_BLOCK_ID, 4);
 
diff --git a/lib/Serialization/SerializedModuleLoader.cpp b/lib/Serialization/SerializedModuleLoader.cpp
diff --git a/test/ModuleInterface/ModuleCache/cxx-interop-caching.swift b/test/ModuleInterface/ModuleCache/cxx-interop-caching.swift
diff --git a/tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp b/tools/lldb-moduleimport-test/lldb-moduleimport-test.cpp
diff --git a/unittests/FrontendTool/ModuleLoadingTests.cpp b/unittests/FrontendTool/ModuleLoadingTests.cpp

Original file line number	Diff line number	Diff line change
`@@ -280,6 +280,8 @@ SerializationOptions CompilerInvocation::computeSerializationOptions(`
`280`	`280`	`}`
`281`	`281`
`282`	`282`	`serializationOpts.IsOSSA = getSILOptions().EnableOSSAModules;`
	`283`	`+ serializationOpts.IsCXXInterop =`
	`284`	`+ getLangOptions().EnableCXXInterop;`
`283`	`285`
`284`	`286`	`serializationOpts.SkipNonExportableDecls =`
`285`	`287`	`getLangOptions().SkipNonExportableDecls;`
Original file line number	Diff line number	Diff line change
`@@ -307,6 +307,8 @@ std::error_code ExplicitModuleInterfaceBuilder::buildSwiftModuleFromInterface(`
`307`	`307`	`SerializationOpts.Dependencies = Deps;`
`308`	`308`	`}`
`309`	`309`	`SerializationOpts.IsOSSA = SILOpts.EnableOSSAModules;`
	`310`	`+ SerializationOpts.IsCXXInterop =`
	`311`	`+ Instance.getASTContext().LangOpts.EnableCXXInterop;`
`310`	`312`
`311`	`313`	`SILMod->setSerializeSILAction([&]() {`
`312`	`314`	`// We don't want to serialize module docs in the cache -- they`