Fix ASTMangler mangling NS_OPTION differently in C++ mode

CF_OPTIONS is defined differently in the SDK based on
a __cplusplus preprocessor branch. As a result, declarations
referencing CF_OPTIONS are mangled differently depending
on if C++ interop is enabled.

This meant a module compiled with cxx interop on could
not be linked with a module compiled without and vice versa.
This patch modifies the mangler such that the mangled names
are consistent. This is achieved by feeding the mangler a modified
AST node that looks like the Objective-C definition of CF_OPTIONS,
even when we have cxx interop enabled.

Author: NuriAmari

include/swift/AST/ASTMangler.h

@@ -384,7 +384,22 @@ class ASTMangler : public Mangler {
   static Optional<SpecialContext>
   getSpecialManglingContext(const ValueDecl *decl, bool useObjCProtocolNames);
 
-  static const clang::NamedDecl *
+  struct ClangDeclForManglingContainer {
+    const clang::NamedDecl *decl;
+    std::function<void(const clang::NamedDecl *)> cleanup;
+
+    operator bool() const { return decl; }
+
+    ClangDeclForManglingContainer(
+        const clang::NamedDecl *decl,
+        std::function<void(const clang::NamedDecl *)> cleanup)
+        : decl{decl}, cleanup{cleanup} {}
+    ClangDeclForManglingContainer(const clang::NamedDecl *decl)
+        : decl{decl}, cleanup{[](const clang::NamedDecl *) {}} {}
+    ~ClangDeclForManglingContainer() { cleanup(decl); }
+  };
+
+  static const ClangDeclForManglingContainer
   getClangDeclForMangling(const ValueDecl *decl);
 
   void appendExistentialLayout(

include/swift/AST/ClangModuleLoader.h

@@ -286,6 +286,8 @@ class ClangModuleLoader : public ModuleLoader {
   /// Determine the effective Clang context for the given Swift nominal type.
   virtual EffectiveClangContext getEffectiveClangContext(
       const NominalTypeDecl *nominal) = 0;
+
+  virtual const clang::TypedefType* getTypeDefForCXXCFOptionsDefinition(const clang::Decl* candidateDecl) = 0;
 };
 
 /// Describes a C++ template instantiation error.

include/swift/ClangImporter/ClangImporter.h

@@ -558,6 +558,8 @@ class ClangImporter final : public ClangModuleLoader {
 
   /// Enable the symbolic import experimental feature for the given callback.
   void withSymbolicFeatureEnabled(llvm::function_ref<void(void)> callback);
+
+  const clang::TypedefType* getTypeDefForCXXCFOptionsDefinition(const clang::Decl* candidateDecl) override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

lib/AST/ASTMangler.cpp

@@ -486,10 +486,10 @@ void ASTMangler::beginManglingWithAutoDiffOriginalFunction(
   }
   // For imported Clang declarations, use the Clang name in order to match how
   // DifferentiationMangler handles these.
-  auto clangDecl = getClangDeclForMangling(afd);
-  if (clangDecl) {
+  auto clangDeclContainer = getClangDeclForMangling(afd);
+  if (clangDeclContainer) {
     beginManglingWithoutPrefix();
-    appendOperator(clangDecl->getName());
+    appendOperator(clangDeclContainer.decl->getName());
     return;
   }
   beginMangling();
@@ -2167,9 +2167,19 @@ ASTMangler::getSpecialManglingContext(const ValueDecl *decl,
   if (isa<TypeDecl>(decl)) {
     if (auto *clangDecl = cast_or_null<clang::NamedDecl>(decl->getClangDecl())){
       bool hasNameForLinkage;
-      if (auto *tagDecl = dyn_cast<clang::TagDecl>(clangDecl))
+      if (auto *tagDecl = dyn_cast<clang::TagDecl>(clangDecl)) {
         hasNameForLinkage = tagDecl->hasNameForLinkage();
-      else
+        // Clang does not always populate the fields that determine if a tag
+        // decl has a linkage name in the ways we expect. To support differing
+        // definitions of CF_OPTIONS, we check if the tag decls is anonymous and
+        // backed by an unavailable typedef.
+        if (!hasNameForLinkage) {
+          const auto& clangImporter = decl->getASTContext().getClangModuleLoader();
+          if (clangImporter->getTypeDefForCXXCFOptionsDefinition(tagDecl)) {
+              hasNameForLinkage = true;
+          }
+        }
+      } else
         hasNameForLinkage = !clangDecl->getDeclName().isEmpty();
       if (hasNameForLinkage) {
         auto *clangDC = clangDecl->getDeclContext();
@@ -2506,17 +2516,39 @@ void ASTMangler::appendProtocolName(const ProtocolDecl *protocol,
     appendDeclName(protocol);
 }
 
-const clang::NamedDecl *ASTMangler::getClangDeclForMangling(const ValueDecl *vd) {
-  auto namedDecl =  dyn_cast_or_null<clang::NamedDecl>(vd->getClangDecl());
+const ASTMangler::ClangDeclForManglingContainer
+ASTMangler::getClangDeclForMangling(const ValueDecl *vd) {
+  auto namedDecl = dyn_cast_or_null<clang::NamedDecl>(vd->getClangDecl());
   if (!namedDecl)
     return nullptr;
-  
+
   // Use an anonymous enum's enclosing typedef for the mangled name, if
   // present. This matches C++'s rules for linkage names of tag declarations.
   if (namedDecl->getDeclName().isEmpty())
-    if (auto *tagDecl = dyn_cast<clang::TagDecl>(namedDecl))
-      if (auto *typedefDecl = tagDecl->getTypedefNameForAnonDecl())
+    if (auto *tagDecl = dyn_cast<clang::TagDecl>(namedDecl)) {
+      // CF_OPTION derived types are different in Objective-C vs Objective-C++
+      // due different definitions in the SDK based on if __cplusplus is
+      // defined. The linkage name of these CF_OPTION derived types must be
+      // consistent regardless of if cxx interop is turned on or not,
+      // otherwise modules compiled with cxx interop cannot interoperate with
+      // those compiled without it.
+      const auto& clangModuleLoader = vd->getASTContext().getClangModuleLoader();
+      if (auto typedefType = clangModuleLoader->getTypeDefForCXXCFOptionsDefinition(tagDecl)) {
+          // Temporarily emulate the Objective-C definition of CF_OPTION
+          // for mangling, removing the temporary name attached to the
+          // anonymous enum once we are done with the value.
+          const_cast<clang::NamedDecl *>(namedDecl)->setDeclName(
+              typedefType->getDecl()->getDeclName());
+          return {namedDecl, [](const clang::NamedDecl *decl) {
+                    const_cast<clang::NamedDecl *>(decl)->setDeclName(
+                        clang::DeclarationName());
+                  }};
+      }
+
+      if (auto *typedefDecl = tagDecl->getTypedefNameForAnonDecl()) {
         namedDecl = typedefDecl;
+      }
+    }
 
   if (namedDecl->getDeclName().isEmpty())
     return nullptr;
@@ -2571,10 +2603,12 @@ void ASTMangler::appendAnyGenericType(const GenericTypeDecl *decl) {
   // have one.
   auto tryAppendClangName = [this, decl]() -> bool {
     auto *nominal = dyn_cast<NominalTypeDecl>(decl);
-    auto namedDecl = getClangDeclForMangling(decl);
-    if (!namedDecl)
+    auto namedDeclContainer = getClangDeclForMangling(decl);
+    if (!namedDeclContainer)
       return false;
 
+    const clang::NamedDecl *namedDecl = namedDeclContainer.decl;
+
     // Mangle ObjC classes using their runtime names.
     auto interface = dyn_cast<clang::ObjCInterfaceDecl>(namedDecl);
     auto protocol = dyn_cast<clang::ObjCProtocolDecl>(namedDecl);

lib/ClangImporter/ClangImporter.cpp

@@ -6580,6 +6580,32 @@ void ClangImporter::withSymbolicFeatureEnabled(
       oldImportSymbolicCXXDecls.get());
 }
 
+const clang::TypedefType* ClangImporter::getTypeDefForCXXCFOptionsDefinition(const clang::Decl* candidateDecl) {
+
+  if (!Impl.SwiftContext.LangOpts.EnableCXXInterop)
+    return nullptr;
+
+  auto enumDecl = dyn_cast<clang::EnumDecl>(candidateDecl);
+  if (!enumDecl)
+    return nullptr;
+
+  if (!enumDecl->getDeclName().isEmpty())
+    return nullptr;
+
+  clang::SourceManager& SM = getClangASTContext().getSourceManager();
+  clang::SourceLocation SpellingLoc = SM.getSpellingLoc(enumDecl->getLocation());
+  clang::PresumedLoc PLoc = SM.getPresumedLoc(SpellingLoc);
+  if (PLoc.isValid() && !strstr(PLoc.getFilename(), "CFAvailability"))
+    return nullptr;
+
+  if (auto typedefType = dyn_cast<clang::TypedefType>(
+          enumDecl->getIntegerType().getTypePtr())) {
+    return Impl.isUnavailableInSwift(typedefType->getDecl()) ? typedefType : nullptr;
+  }
+
+  return nullptr;
+}
+
 bool importer::requiresCPlusPlus(const clang::Module *module) {
   // The libc++ modulemap doesn't currently declare the requirement.
   if (module->getTopLevelModuleName() == "std")

lib/IRGen/GenMeta.cpp

@@ -1225,8 +1225,10 @@ namespace {
 
         // Otherwise, if this was imported from a Clang declaration, use that
         // declaration's name as the ABI name.
-      } else if (auto clangDecl =
-                            Mangle::ASTMangler::getClangDeclForMangling(Type)) {
+      } else if (auto clangDeclContainer =
+                     Mangle::ASTMangler::getClangDeclForMangling(Type)) {
+
+        const clang::NamedDecl *clangDecl = clangDeclContainer.decl;
         // Class template specializations need to use their mangled name so
         // that each specialization gets its own metadata. A class template
         // specialization's Swift name will always be the mangled name, so just

test/Interop/Cxx/enum/Inputs/CFAvailability.h

@@ -0,0 +1,27 @@
+#if __has_attribute(enum_extensibility)
+#define __CF_ENUM_ATTRIBUTES __attribute__((enum_extensibility(open)))
+#define __CF_CLOSED_ENUM_ATTRIBUTES __attribute__((enum_extensibility(closed)))
+#define __CF_OPTIONS_ATTRIBUTES                                                \
+  __attribute__((flag_enum, enum_extensibility(open)))
+#else
+#define __CF_ENUM_ATTRIBUTES
+#define __CF_CLOSED_ENUM_ATTRIBUTES
+#define __CF_OPTIONS_ATTRIBUTES
+#endif
+
+#if (__cplusplus)
+#define CF_OPTIONS(_type, _name)                                               \
+  _type __attribute__((availability(swift, unavailable))) _name;               \
+  enum __CF_OPTIONS_ATTRIBUTES : _name
+#else
+#define CF_OPTIONS(_type, _name)                                               \
+  enum __CF_OPTIONS_ATTRIBUTES _name : _type _name;                            \
+  enum _name : _type
+#endif
+
+#define NS_OPTIONS(_type, _name) CF_OPTIONS(_type, _name)
+
+typedef NS_OPTIONS(int, StandardNSOption) {
+  StandardNSOption1,
+  StandardNSOption2
+};

test/Interop/Cxx/enum/Inputs/module.modulemap

@@ -32,3 +32,7 @@ module CenumsNSOptionsExternC [extern_c] {
   header "c-enums-NS_OPTIONS_without_extern_C.h"
   requires cplusplus
 }
+
+module CFAvailability {
+    header "CFAvailability.h"
+}

test/Interop/Cxx/enum/c-enums-NS_OPTIONS-consistent-linkage-name.swift

@@ -0,0 +1,16 @@
+// RUN: %empty-directory(%t/cache)
+// RUN: %target-swift-frontend %s -I %S/Inputs -c -enable-experimental-cxx-interop -o %t/object.o
+// RUN: %llvm-nm %t/object.o > %t/results.txt
+// RUN: %target-swift-frontend %s -I %S/Inputs -c -enable-objc-interop -o %t/object.o
+// RUN: %llvm-nm %t/object.o >> %t/results.txt
+// RUN: cat %t/results.txt | %FileCheck %s
+
+// REQUIRES: objc_interop
+
+import CFAvailability
+
+// Verify that this functions linkage name is the name with or without cxx interop enabled
+public func useNSOption(foo param: StandardNSOption) {}
+
+// CHECK: [[FUNC_LINKAGE_NAME:\$s.*useNSOption.*$]]
+// CHECK: [[FUNC_LINKAGE_NAME]]