Merge pull request #65496 from hyp/eng/reverse-interop-5.9-enums

[5.9\[interop][SwiftToCxx] add additional type representation emission checks

Author: hyp

lib/AST/SwiftNameTranslation.cpp

@@ -249,9 +249,11 @@ swift::cxx_translation::getDeclRepresentation(const ValueDecl *VD) {
             return {Unsupported, UnrepresentableEnumCaseTuple};
           for (const auto *param : *params) {
             auto paramType = param->getInterfaceType();
-            if (!paramType->is<GenericTypeParamType>() &&
-                !paramType->getNominalOrBoundGenericNominal())
-              return {Unsupported, UnrepresentableEnumCaseType};
+            if (!paramType->is<GenericTypeParamType>()) {
+              auto *nominal = paramType->getNominalOrBoundGenericNominal();
+              if (!nominal || isa<ProtocolDecl>(nominal))
+                return {Unsupported, UnrepresentableEnumCaseType};
+            }
           }
         }
       }

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -406,7 +406,6 @@ class DeclAndTypePrinter::Implementation
   void visitEnumDeclCxx(EnumDecl *ED) {
     assert(owningPrinter.outputLang == OutputLanguageMode::Cxx);
 
-    // FIXME: Print enum's availability
     ClangValueTypePrinter valueTypePrinter(os, owningPrinter.prologueOS,
                                            owningPrinter.interopContext);
     ClangSyntaxPrinter syntaxPrinter(os);
@@ -2793,12 +2792,43 @@ static bool isExposedToThisModule(const ModuleDecl &M, const ValueDecl *VD,
   return exposedModules.count(mc->getName().str());
 }
 
+static bool isEnumExposableToCxx(const ValueDecl *VD,
+                                 DeclAndTypePrinter &printer) {
+  auto *enumDecl = dyn_cast<EnumDecl>(VD);
+  if (!enumDecl)
+    return true;
+  // The supported set of enum elements is restricted by
+  // the types that can be represented in C++. We already
+  // check for different type categories in `getDeclRepresentation`, however,
+  // we also need to perform additional check on whether the type can be
+  // emitted here as well, to ensure that we don't emit types from dependent
+  // modules that do not have a C++ representation.
+  for (const auto *enumCase : enumDecl->getAllCases()) {
+    for (const auto *elementDecl : enumCase->getElements()) {
+      if (!elementDecl->hasAssociatedValues())
+        continue;
+      if (auto *params = elementDecl->getParameterList()) {
+        for (const auto *param : *params) {
+          auto paramType = param->getInterfaceType();
+          if (DeclAndTypeClangFunctionPrinter::getTypeRepresentation(
+                  printer.getTypeMapping(), printer.getInteropContext(),
+                  printer, enumDecl->getModuleContext(), paramType)
+                  .isUnsupported())
+            return false;
+        }
+      }
+    }
+  }
+  return true;
+}
+
 bool DeclAndTypePrinter::shouldInclude(const ValueDecl *VD) {
   return !VD->isInvalid() && (!requiresExposedAttribute || hasExposeAttr(VD)) &&
          (outputLang == OutputLanguageMode::Cxx
               ? cxx_translation::isVisibleToCxx(VD, minRequiredAccess) &&
                     isExposedToThisModule(M, VD, exposedModules) &&
-                    cxx_translation::isExposableToCxx(VD)
+                    cxx_translation::isExposableToCxx(VD) &&
+                    isEnumExposableToCxx(VD, *this)
               : isVisibleToObjC(VD, minRequiredAccess)) &&
          !VD->getAttrs().hasAttribute<ImplementationOnlyAttr>() &&
          !isAsyncAlternativeOfOtherDecl(VD) &&

lib/PrintAsClang/DeclAndTypePrinter.h

@@ -75,6 +75,8 @@ class DeclAndTypePrinter {
         requiresExposedAttribute(requiresExposedAttribute),
         exposedModules(exposedModules), outputLang(outputLang) {}
 
+  PrimitiveTypeMapping &getTypeMapping() { return typeMapping; }
+
   SwiftToClangInteropContext &getInteropContext() { return interopContext; }
 
   /// Returns true if \p VD should be included in a compatibility header for

lib/PrintAsClang/PrintClangFunction.cpp

@@ -1581,3 +1581,16 @@ void DeclAndTypeClangFunctionPrinter::printCustomCxxFunction(
   bodyPrinter(typeRefs);
   outOfLineOS << "}\n";
 }
+
+ClangRepresentation DeclAndTypeClangFunctionPrinter::getTypeRepresentation(
+    PrimitiveTypeMapping &typeMapping,
+    SwiftToClangInteropContext &interopContext, DeclAndTypePrinter &declPrinter,
+    const ModuleDecl *emittedModule, Type ty) {
+  CFunctionSignatureTypePrinterModifierDelegate delegate;
+  CFunctionSignatureTypePrinter typePrinter(
+      llvm::nulls(), llvm::nulls(), typeMapping, OutputLanguageMode::Cxx,
+      interopContext, delegate, emittedModule, declPrinter,
+      FunctionSignatureTypeUse::TypeReference);
+  return typePrinter.visit(ty, OptionalTypeKind::OTK_None,
+                           /*isInOutParam=*/false);
+}

lib/PrintAsClang/PrintClangFunction.h

@@ -164,6 +164,12 @@ class DeclAndTypeClangFunctionPrinter {
                               ModuleDecl *emittedModule,
                               raw_ostream &outOfLineOS);
 
+  static ClangRepresentation
+  getTypeRepresentation(PrimitiveTypeMapping &typeMapping,
+                        SwiftToClangInteropContext &interopContext,
+                        DeclAndTypePrinter &declPrinter,
+                        const ModuleDecl *emittedModule, Type ty);
+
 private:
   void printCxxToCFunctionParameterUse(Type type, StringRef name,
                                        const ModuleDecl *moduleContext,

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

@@ -0,0 +1,17 @@
+// RUN: %empty-directory(%t)
+
+// RUN: %target-swift-frontend -typecheck %s -typecheck -module-name UseFoundation -enable-experimental-cxx-interop -emit-clang-header-path %t/UseFoundation.h
+// RUN: %FileCheck %s < %t/UseFoundation.h
+
+#if canImport(Foundation)
+
+import Foundation
+
+public enum UseFoundationEnum {
+    case A(Data)
+    case B
+}
+
+#endif
+
+// CHECK-NOT: UseFoundationEnum

test/Interop/SwiftToCxx/unsupported/unsupported-enums-in-cxx.swift

@@ -27,3 +27,8 @@ public indirect enum unsupportedEnumIndirect {
     case B
 }
 
+@_expose(Cxx) // expected-error {{enum 'unsupportedEnumProtocolType' can not be represented in C++ as one of its cases has an associated value with type that can't be represented in C++}}
+public enum unsupportedEnumProtocolType {
+    case A
+    case B(Error)
+}