[cxx-interop] Types exposed from ObjC modules should be behind a macro

Functions or template instantiations with Obj-C types should always be
behind a macro to make sure the interop header compiles cleanly in C++.

rdar://152836730

Author: Gabor Horvath

include/swift/AST/SwiftNameTranslation.h

@@ -112,6 +112,9 @@ inline bool isExposableToCxx(
   return !getDeclRepresentation(VD, isZeroSized).isUnsupported();
 }
 
+bool isObjCxxOnly(const ValueDecl *VD);
+bool isObjCxxOnly(const clang::Decl *D);
+
 /// Returns true if the given value decl D is visible to C++ of its
 /// own accord (i.e. without considering its context)
 bool isVisibleToCxx(const ValueDecl *VD, AccessLevel minRequiredAccess,

lib/AST/SwiftNameTranslation.cpp

@@ -29,6 +29,7 @@
 #include "swift/Basic/StringExtras.h"
 
 #include "clang/AST/DeclObjC.h"
+#include "clang/Basic/Module.h"
 #include "llvm/ADT/SmallString.h"
 #include <optional>
 
@@ -237,6 +238,39 @@ swift::cxx_translation::getNameForCxx(const ValueDecl *VD,
   return VD->getBaseIdentifier().str();
 }
 
+namespace {
+struct ObjCTypeWalker : TypeWalker {
+  bool hadObjCType = false;
+  Action walkToTypePre(Type ty) override {
+    if (auto *nominal = ty->getNominalOrBoundGenericNominal()) {
+      if (auto clangDecl = nominal->getClangDecl()) {
+        if (cxx_translation::isObjCxxOnly(clangDecl)) {
+          hadObjCType = true;
+          return Action::Stop;
+        }
+      }
+    }
+    return Action::Continue;
+  }
+};
+} // namespace
+
+bool swift::cxx_translation::isObjCxxOnly(const ValueDecl *VD) {
+  ObjCTypeWalker walker;
+  VD->getInterfaceType().walk(walker);
+  return walker.hadObjCType;
+}
+
+bool swift::cxx_translation::isObjCxxOnly(const clang::Decl *D) {
+  // By default, we import all modules in Obj-C++ mode, so there is no robust
+  // way to tell if something is coming from an Obj-C module. The best
+  // approximation is to check if something is a framework module as most of
+  // those are written in Obj-C. Ideally, we want to add `requires ObjC` to all
+  // ObjC modules and respect that here to make this completely precise.
+  return D->getASTContext().getLangOpts().ObjC &&
+         D->getOwningModule()->isPartOfFramework();
+}
+
 swift::cxx_translation::DeclRepresentation
 swift::cxx_translation::getDeclRepresentation(
     const ValueDecl *VD,
@@ -323,6 +357,9 @@ swift::cxx_translation::getDeclRepresentation(
     return {Unsupported, UnrepresentableGenericRequirements};
   }
 
+  if (isObjCxxOnly(VD))
+    return {ObjCxxOnly, std::nullopt};
+
   return {Representable, std::nullopt};
 }
 

lib/PrintAsClang/PrintClangFunction.cpp

@@ -812,7 +812,8 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
     ClangSyntaxPrinter(FD->getASTContext(), functionSignatureOS).printInlineForThunk();
 
   ClangRepresentation resultingRepresentation =
-      ClangRepresentation::representable;
+      cxx_translation::isObjCxxOnly(FD) ? ClangRepresentation::objcxxonly
+                                        : ClangRepresentation::representable;
 
   // Print out the return type.
   if (FD->hasThrows() && outputLang == OutputLanguageMode::Cxx)

lib/PrintAsClang/PrintClangValueType.cpp

@@ -22,6 +22,7 @@
 #include "swift/ClangImporter/ClangImporter.h"
 #include "swift/IRGen/IRABIDetailsProvider.h"
 #include "swift/IRGen/Linking.h"
+#include "clang/Basic/Module.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
@@ -616,20 +617,28 @@ void ClangValueTypePrinter::printTypeGenericTraits(
     });
   }
 
+  bool objCxxOnly = false;
+  if (const auto *clangDecl = typeDecl->getClangDecl()) {
+    if (cxx_translation::isObjCxxOnly(clangDecl))
+      objCxxOnly = true;
+  }
+
   // FIXME: avoid popping out of the module's namespace here.
   os << "} // end namespace \n\n";
   os << "namespace swift SWIFT_PRIVATE_ATTR {\n";
   auto classDecl = dyn_cast<ClassDecl>(typeDecl);
   bool addPointer =
       typeDecl->isObjC() || (classDecl && classDecl->isForeignReferenceType());
 
+  if (objCxxOnly)
+    os << "#if defined(__OBJC__)\n";
   os << "#pragma clang diagnostic push\n";
   os << "#pragma clang diagnostic ignored \"-Wc++17-extensions\"\n";
-  if (typeDecl->hasClangNode()) {
+  if (const auto *clangDecl = typeDecl->getClangDecl()) {
     // FIXME: share the code.
     os << "template<>\n";
     os << "inline const constexpr bool isUsableInGenericContext<";
-    printer.printClangTypeReference(typeDecl->getClangDecl());
+    printer.printClangTypeReference(clangDecl);
     if (addPointer)
       os << "*";
     os << "> = true;\n";
@@ -639,8 +648,8 @@ void ClangValueTypePrinter::printTypeGenericTraits(
   os << "struct";
   declAndTypePrinter.printAvailability(os, typeDecl);
   os << " TypeMetadataTrait<";
-  if (typeDecl->hasClangNode()) {
-    printer.printClangTypeReference(typeDecl->getClangDecl());
+  if (const auto *clangDecl = typeDecl->getClangDecl()) {
+    printer.printClangTypeReference(clangDecl);
     if (addPointer)
       os << "*";
   } else {
@@ -720,6 +729,8 @@ void ClangValueTypePrinter::printTypeGenericTraits(
   }
   os << "} // namespace\n";
   os << "#pragma clang diagnostic pop\n";
+  if (objCxxOnly)
+    os << "#endif // #if defined(__OBJC__)\n";
   os << "} // namespace swift\n";
   os << "\n";
   printer.printModuleNamespaceStart(*moduleContext);

test/Interop/SwiftToCxx/stdlib/foundation-type-not-exposed-by-default-to-cxx.swift

@@ -3,6 +3,8 @@
 // RUN: %target-swift-frontend %s -module-name UseFoundation -enable-experimental-cxx-interop -typecheck -verify -emit-clang-header-path %t/UseFoundation.h
 // RUN: %FileCheck %s < %t/UseFoundation.h
 
+// RUN: %check-interop-cxx-header-in-clang(%t/UseFoundation.h -DSWIFT_CXX_INTEROP_HIDE_STL_OVERLAY)
+
 // REQUIRES: objc_interop
 
 import Foundation
@@ -12,4 +14,8 @@ public enum UseFoundationEnum {
     case B
 }
 
+public func f() -> NSEdgeInsets {
+    NSEdgeInsets()
+}
+
 // CHECK: class UseFoundationEnum { } SWIFT_UNAVAILABLE_MSG("Swift enum 'UseFoundationEnum' cannot be represented in C++");