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(

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,29 @@ 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) {
+          if (auto enumDecl = dyn_cast<clang::EnumDecl>(tagDecl);
+              decl->getASTContext().LangOpts.EnableCXXInterop &&
+              enumDecl->getDeclName().isEmpty()) {
+            if (auto typedefType = dyn_cast<clang::TypedefType>(
+                    enumDecl->getIntegerType().getTypePtr())) {
+              for (auto *attr :
+                   typedefType->getDecl()
+                       ->specific_attrs<clang::AvailabilityAttr>()) {
+                if (attr->getPlatform()->getName() == "swift") {
+                  hasNameForLinkage = true;
+                }
+              }
+            }
+          }
+        }
+      } else
         hasNameForLinkage = !clangDecl->getDeclName().isEmpty();
       if (hasNameForLinkage) {
         auto *clangDC = clangDecl->getDeclContext();
@@ -2506,17 +2526,47 @@ 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)) {
+      if (auto enumDecl = dyn_cast<clang::EnumDecl>(tagDecl)) {
+        // 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.
+        if (auto typedefType = dyn_cast<clang::TypedefType>(
+                enumDecl->getIntegerType().getTypePtr());
+            vd->getASTContext().LangOpts.EnableCXXInterop) {
+          for (auto *attr : typedefType->getDecl()
+                                ->specific_attrs<clang::AvailabilityAttr>()) {
+            if (attr->getPlatform()->getName() == "swift") {
+              // 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 +2621,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/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/SimpleNSOption.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 SimpleNSOption {
+    header "SimpleNSOption.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 SimpleNSOption
+
+// 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]]