[cxx-interop] Do not emit C++ interop flag in textual interfaces

This makes sure that the compiler does not emit `-enable-experimental-cxx-interop`/`-cxx-interoperability-mode` flags in `.swiftinterface` files. Those flags were breaking explicit module builds. The module can still be rebuilt from its textual interface if C++ interop was enabled in the current compilation.

rdar://140203932

Author: egorzhdan

include/swift/Option/Options.td

@@ -794,12 +794,12 @@ def enable_experimental_concise_pound_file : Flag<["-"],
 
 def enable_experimental_cxx_interop :
   Flag<["-"], "enable-experimental-cxx-interop">,
-  Flags<[NoDriverOption, FrontendOption, HelpHidden, ModuleInterfaceOption]>,
+  Flags<[NoDriverOption, FrontendOption, HelpHidden]>,
   HelpText<"Enable experimental C++ interop code generation and config directives">;
 
 def cxx_interoperability_mode :
   Joined<["-"], "cxx-interoperability-mode=">,
-  Flags<[FrontendOption, ModuleInterfaceOption, SwiftSymbolGraphExtractOption,
+  Flags<[FrontendOption, SwiftSymbolGraphExtractOption,
          SwiftSynthesizeInterfaceOption]>,
   HelpText<"Enables C++ interoperability; pass 'default' to enable or 'off' to disable">;
 

lib/Frontend/ModuleInterfaceLoader.cpp

@@ -2016,10 +2016,7 @@ InterfaceSubContextDelegateImpl::InterfaceSubContextDelegateImpl(
 
   // For now, we only inherit the C++ interoperability mode in
   // Explicit Module Builds.
-  if (langOpts.EnableCXXInterop &&
-      (frontendOpts.DisableImplicitModules ||
-       LoaderOpts.requestedAction ==
-           FrontendOptions::ActionType::ScanDependencies)) {
+  if (langOpts.EnableCXXInterop) {
     // Modelled after a reverse of validateCxxInteropCompatibilityMode
     genericSubInvocation.getLangOptions().EnableCXXInterop = true;
     genericSubInvocation.getLangOptions().cxxInteropCompatVersion =
@@ -2208,6 +2205,16 @@ InterfaceSubContextDelegateImpl::runInSubCompilerInstance(StringRef moduleName,
   BuildArgs.push_back("-module-name");
   BuildArgs.push_back(moduleName);
 
+  // FIXME: Hack for Darwin.swiftmodule, which cannot be rebuilt with C++
+  // interop enabled.
+  if (moduleName == "Darwin") {
+    subInvocation.getLangOptions().EnableCXXInterop = false;
+    subInvocation.getLangOptions().cxxInteropCompatVersion = {};
+    llvm::remove_if(BuildArgs, [](StringRef arg) -> bool {
+      return arg.starts_with("-cxx-interoperability-mode=");
+    });
+  }
+
   // Calculate output path of the module.
   llvm::SmallString<256> buffer;
   StringRef CacheHash;

lib/Sema/TypeCheckAccess.cpp

@@ -28,6 +28,7 @@
 #include "swift/AST/Pattern.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Assertions.h"
+#include "clang/Basic/Module.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 
@@ -1849,6 +1850,9 @@ bool isFragileClangNode(const ClangNode &node) {
   auto *decl = node.getAsDecl();
   if (!decl)
     return false;
+  // Types in the Darwin module are not always guarded by `extern "C"`.
+  if (decl->getOwningModule()->getTopLevelModuleName() == "Darwin")
+    return false;
   // Namespaces by themselves don't impact ABI.
   if (isa<clang::NamespaceDecl>(decl))
     return false;
@@ -1882,9 +1886,15 @@ bool isFragileClangNode(const ClangNode &node) {
   // with library evolution if its type is compatible.
   if (auto *pd = dyn_cast<clang::ObjCPropertyDecl>(decl))
     return isFragileClangType(pd->getType());
+  if (auto *fieldDecl = dyn_cast<clang::FieldDecl>(decl))
+    return isFragileClangType(fieldDecl->getType());
   if (auto *typedefDecl = dyn_cast<clang::TypedefNameDecl>(decl))
     return isFragileClangType(typedefDecl->getUnderlyingType());
-  if (auto *rd = dyn_cast<clang::RecordDecl>(decl)) {
+  if (auto *rd = dyn_cast<clang::TagDecl>(decl)) {
+    if (auto *enumDecl = dyn_cast<clang::EnumDecl>(rd))
+      // Scoped enums only exist in C++ and therefore are always fragile.
+      if (enumDecl->isScoped())
+        return true;
     if (!isa<clang::CXXRecordDecl>(rd))
       return false;
     return !rd->getDeclContext()->isExternCContext();

test/Interop/Cxx/modules/emit-module-interface.swift

@@ -3,15 +3,18 @@
 // Check if fragile Swift interface with struct
 // extensions can be reparsed:
 // RUN: %target-swift-frontend -swift-version 5 -typecheck -emit-module-interface-path %t/UsesCxxStruct.swiftinterface %s -I %S/Inputs -swift-version 5 -enable-experimental-cxx-interop %S/Inputs/namespace-extension-lib.swift
-// RUN: %target-swift-frontend -swift-version 5 -typecheck-module-from-interface  %t/UsesCxxStruct.swiftinterface -I %S/Inputs
+// RUN: %target-swift-frontend -swift-version 5 -typecheck-module-from-interface  %t/UsesCxxStruct.swiftinterface -I %S/Inputs -enable-experimental-cxx-interop
 // RUN: %FileCheck --input-file=%t/UsesCxxStruct.swiftinterface %s
-// CHECK: -enable-experimental-cxx-interop
+
+// The textual module interface should not contain the C++ interop flag.
+// CHECK-NOT: -enable-experimental-cxx-interop
+// CHECK-NOT: -cxx-interoperability-mode
 
 
 // Check if resilient Swift interface with builtin
 // type extensions can be reparsed:
 // RUN: %target-swift-emit-module-interface(%t/ResilientStruct.swiftinterface) %s -I %S/Inputs -enable-library-evolution -swift-version 5 -enable-experimental-cxx-interop %S/Inputs/namespace-extension-lib.swift -DRESILIENT
-// RUN: %target-swift-typecheck-module-from-interface(%t/ResilientStruct.swiftinterface) -I %S/Inputs -DRESILIENT
+// RUN: %target-swift-typecheck-module-from-interface(%t/ResilientStruct.swiftinterface) -I %S/Inputs -DRESILIENT -enable-experimental-cxx-interop
 // RUN: %FileCheck --input-file=%t/ResilientStruct.swiftinterface %s
 
 import Namespaces

validation-test/ParseableInterface/verify_all_overlays.py

@@ -46,7 +46,8 @@
         "DifferentiationUnittest",
         "Swift",
         "SwiftLang",
-        "std",  # swiftstd uses `-module-interface-preserve-types-as-written`
+        # swiftCxxStdlib uses `-module-interface-preserve-types-as-written`
+        "CxxStdlib",
     ]:
         continue