[interop][SwiftToCxx] do not emit functions/methods that use unexposed types

Author: hyp

lib/PrintAsClang/DeclAndTypePrinter.cpp

@@ -426,7 +426,7 @@ class DeclAndTypePrinter::Implementation
       // Printing struct, is, and get functions for each case
       DeclAndTypeClangFunctionPrinter clangFuncPrinter(
           os, owningPrinter.prologueOS, owningPrinter.typeMapping,
-          owningPrinter.interopContext);
+          owningPrinter.interopContext, owningPrinter);
 
       auto printIsFunction = [&](StringRef caseName, EnumDecl *ED) {
         os << "  inline bool is";
@@ -745,9 +745,9 @@ class DeclAndTypePrinter::Implementation
         return;
       owningPrinter.prologueOS << cFuncPrologueOS.str();
 
-      DeclAndTypeClangFunctionPrinter declPrinter(os, owningPrinter.prologueOS,
-                                                  owningPrinter.typeMapping,
-                                                  owningPrinter.interopContext);
+      DeclAndTypeClangFunctionPrinter declPrinter(
+          os, owningPrinter.prologueOS, owningPrinter.typeMapping,
+          owningPrinter.interopContext, owningPrinter);
       if (auto *accessor = dyn_cast<AccessorDecl>(AFD)) {
         declPrinter.printCxxPropertyAccessorMethod(
             typeDeclContext, accessor, funcABI->getSymbolName(), resultTy,
@@ -760,7 +760,8 @@ class DeclAndTypePrinter::Implementation
 
       DeclAndTypeClangFunctionPrinter defPrinter(
           owningPrinter.outOfLineDefinitionsOS, owningPrinter.prologueOS,
-          owningPrinter.typeMapping, owningPrinter.interopContext);
+          owningPrinter.typeMapping, owningPrinter.interopContext,
+          owningPrinter);
 
       if (auto *accessor = dyn_cast<AccessorDecl>(AFD)) {
 
@@ -1131,7 +1132,7 @@ class DeclAndTypePrinter::Implementation
 
     DeclAndTypeClangFunctionPrinter funcPrinter(
         cRepresentationOS, owningPrinter.prologueOS, owningPrinter.typeMapping,
-        owningPrinter.interopContext);
+        owningPrinter.interopContext, owningPrinter);
     auto ABIparams = owningPrinter.interopContext.getIrABIDetails()
                          .getFunctionABIAdditionalParams(FD);
     llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
@@ -1191,9 +1192,9 @@ class DeclAndTypePrinter::Implementation
     auto resultTy =
         getForeignResultType(FD, funcTy, asyncConvention, errorConvention);
 
-    DeclAndTypeClangFunctionPrinter funcPrinter(os, owningPrinter.prologueOS,
-                                                owningPrinter.typeMapping,
-                                                owningPrinter.interopContext);
+    DeclAndTypeClangFunctionPrinter funcPrinter(
+        os, owningPrinter.prologueOS, owningPrinter.typeMapping,
+        owningPrinter.interopContext, owningPrinter);
     llvm::SmallVector<DeclAndTypeClangFunctionPrinter::AdditionalParam, 2>
         additionalParams;
     auto ABIparams = owningPrinter.interopContext.getIrABIDetails()
@@ -1202,10 +1203,12 @@ class DeclAndTypePrinter::Implementation
       convertABIAdditionalParams(FD, resultTy, ABIparams, additionalParams);
     DeclAndTypeClangFunctionPrinter::FunctionSignatureModifiers modifiers;
     modifiers.isInline = true;
-    funcPrinter.printFunctionSignature(
+    auto result = funcPrinter.printFunctionSignature(
         FD, cxx_translation::getNameForCxx(FD), resultTy,
         DeclAndTypeClangFunctionPrinter::FunctionSignatureKind::CxxInlineThunk,
         {}, modifiers);
+    assert(
+        !result.isUnsupported()); // The C signature should be unsupported too.
     // FIXME: Support throwing exceptions for Swift errors.
     if (!funcTy->isThrowing())
       os << " noexcept";

lib/PrintAsClang/PrintClangFunction.cpp

@@ -96,13 +96,14 @@ class CFunctionSignatureTypePrinter
       PrimitiveTypeMapping &typeMapping, OutputLanguageMode languageMode,
       SwiftToClangInteropContext &interopContext,
       CFunctionSignatureTypePrinterModifierDelegate modifiersDelegate,
-      const ModuleDecl *moduleContext,
+      const ModuleDecl *moduleContext, DeclAndTypePrinter &declPrinter,
       FunctionSignatureTypeUse typeUseKind =
           FunctionSignatureTypeUse::ParamType)
       : ClangSyntaxPrinter(os), cPrologueOS(cPrologueOS),
         typeMapping(typeMapping), interopContext(interopContext),
         languageMode(languageMode), modifiersDelegate(modifiersDelegate),
-        moduleContext(moduleContext), typeUseKind(typeUseKind) {}
+        moduleContext(moduleContext), declPrinter(declPrinter),
+        typeUseKind(typeUseKind) {}
 
   void printInoutTypeModifier() {
     os << (languageMode == swift::OutputLanguageMode::Cxx ? " &"
@@ -197,6 +198,9 @@ class CFunctionSignatureTypePrinter
     // Handle known type names.
     if (printIfKnownSimpleType(decl, optionalKind, isInOutParam))
       return ClangRepresentation::representable;
+    if (!declPrinter.shouldInclude(decl))
+      return ClangRepresentation::unsupported; // FIXME: propagate why it's not
+                                               // exposed.
     // FIXME: Handle optional structures.
     if (typeUseKind == FunctionSignatureTypeUse::ParamType) {
       if (languageMode != OutputLanguageMode::Cxx &&
@@ -292,6 +296,7 @@ class CFunctionSignatureTypePrinter
   OutputLanguageMode languageMode;
   CFunctionSignatureTypePrinterModifierDelegate modifiersDelegate;
   const ModuleDecl *moduleContext;
+  DeclAndTypePrinter &declPrinter;
   FunctionSignatureTypeUse typeUseKind;
 };
 
@@ -304,7 +309,7 @@ DeclAndTypeClangFunctionPrinter::printClangFunctionReturnType(
   CFunctionSignatureTypePrinter typePrinter(
       os, cPrologueOS, typeMapping, outputLang, interopContext,
       CFunctionSignatureTypePrinterModifierDelegate(), moduleContext,
-      FunctionSignatureTypeUse::ReturnType);
+      declPrinter, FunctionSignatureTypeUse::ReturnType);
   // Param for indirect return cannot be marked as inout
   return typePrinter.visit(ty, optKind, /*isInOutParam=*/false);
 }
@@ -344,9 +349,9 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
       -> ClangRepresentation {
     // FIXME: add support for noescape and PrintMultiPartType,
     // see DeclAndTypePrinter::print.
-    CFunctionSignatureTypePrinter typePrinter(os, cPrologueOS, typeMapping,
-                                              outputLang, interopContext,
-                                              delegate, emittedModule);
+    CFunctionSignatureTypePrinter typePrinter(
+        os, cPrologueOS, typeMapping, outputLang, interopContext, delegate,
+        emittedModule, declPrinter);
     auto result = typePrinter.visit(ty, optionalKind, isInOutParam);
 
     if (!name.empty()) {
@@ -385,6 +390,12 @@ ClangRepresentation DeclAndTypeClangFunctionPrinter::printFunctionSignature(
             .isUnsupported())
       return resultingRepresentation;
   } else {
+    // FIXME: also try to figure out if indirect is representable using a type
+    // visitor?
+    if (const auto *NT = resultTy->getNominalOrBoundGenericNominal()) {
+      if (!declPrinter.shouldInclude(NT))
+        return ClangRepresentation::unsupported;
+    }
     os << "void";
   }
 
@@ -701,9 +712,11 @@ void DeclAndTypeClangFunctionPrinter::printCxxMethod(
       isa<FuncDecl>(FD) ? cast<FuncDecl>(FD)->isMutating() : false;
   modifiers.isConst =
       !isa<ClassDecl>(typeDeclContext) && !isMutating && !isConstructor;
-  printFunctionSignature(
+  auto result = printFunctionSignature(
       FD, isConstructor ? "init" : cxx_translation::getNameForCxx(FD), resultTy,
       FunctionSignatureKind::CxxInlineThunk, {}, modifiers);
+  assert(!result.isUnsupported() && "C signature should be unsupported too");
+
   if (!isDefinition) {
     os << ";\n";
     return;
@@ -763,9 +776,10 @@ void DeclAndTypeClangFunctionPrinter::printCxxPropertyAccessorMethod(
     modifiers.qualifierContext = typeDeclContext;
   modifiers.isInline = true;
   modifiers.isConst = accessor->isGetter() && !isa<ClassDecl>(typeDeclContext);
-  printFunctionSignature(accessor, remapPropertyName(accessor, resultTy),
-                         resultTy, FunctionSignatureKind::CxxInlineThunk, {},
-                         modifiers);
+  auto result = printFunctionSignature(
+      accessor, remapPropertyName(accessor, resultTy), resultTy,
+      FunctionSignatureKind::CxxInlineThunk, {}, modifiers);
+  assert(!result.isUnsupported() && "C signature should be unsupported too!");
   if (!isDefinition) {
     os << ";\n";
     return;

lib/PrintAsClang/PrintClangFunction.h

@@ -35,6 +35,7 @@ class ParamDecl;
 class ParameterList;
 class PrimitiveTypeMapping;
 class SwiftToClangInteropContext;
+class DeclAndTypePrinter;
 
 struct ClangRepresentation {
   enum Kind { representable, unsupported };
@@ -61,9 +62,10 @@ class DeclAndTypeClangFunctionPrinter {
 public:
   DeclAndTypeClangFunctionPrinter(raw_ostream &os, raw_ostream &cPrologueOS,
                                   PrimitiveTypeMapping &typeMapping,
-                                  SwiftToClangInteropContext &interopContext)
+                                  SwiftToClangInteropContext &interopContext,
+                                  DeclAndTypePrinter &declPrinter)
       : os(os), cPrologueOS(cPrologueOS), typeMapping(typeMapping),
-        interopContext(interopContext) {}
+        interopContext(interopContext), declPrinter(declPrinter) {}
 
   /// What kind of function signature should be emitted for the given Swift
   /// function.
@@ -150,6 +152,7 @@ class DeclAndTypeClangFunctionPrinter {
   raw_ostream &cPrologueOS;
   PrimitiveTypeMapping &typeMapping;
   SwiftToClangInteropContext &interopContext;
+  DeclAndTypePrinter &declPrinter;
 };
 
 } // end namespace swift

test/Interop/SwiftToCxx/expose-attr/expose-swift-decls-to-cxx.swift

@@ -36,6 +36,10 @@ public struct ExposedStruct {
     public func method() {}
 }
 
+public struct NotExposedStruct {
+    public var x: Int
+}
+
 @_expose(Cxx, "ExposedStruct2")
 public struct ExposedStructRenamed {
     public var y: Int
@@ -48,6 +52,15 @@ public struct ExposedStructRenamed {
 
     @_expose(Cxx, "renamedMethod")
     public func method() {}
+
+    public func getNonExposedStruct() -> NotExposedStruct {
+        return NotExposedStruct(x: 2)
+    }
+    // FIXME: if 'getNonExposedStruct' has explicit @_expose we should error in Sema.
+
+    public func passNonExposedStruct(_ x: NotExposedStruct) {
+    }
+    // FIXME: if 'passNonExposedStruct' has explicit @_expose we should error in Sema.
 }
 
 @_expose(Cxx)
@@ -58,6 +71,14 @@ public final class ExposedClass {
 // CHECK: class ExposedClass final
 // CHECK: class ExposedStruct final {
 // CHECK: class ExposedStruct2 final {
+// CHECK: ExposedStruct2(ExposedStruct2 &&) = default;
+// CHECK-NEXT: swift::Int getY() const;
+// CHECK-NEXT: void setY(swift::Int value);
+// CHECK-NEXT: swift::Int getRenamedProp() const;
+// CHECK-NEXT: void setRenamedProp(swift::Int value);
+// CHECK-NEXT: swift::Int getProp3() const;
+// CHECK-NEXT: void renamedMethod() const;
+// CHECK-NEXT: private:
 
 // CHECK: inline void exposed1() noexcept {
 // CHECK-NEXT:   return _impl::$s6Expose8exposed1yyF();
@@ -84,3 +105,5 @@ public final class ExposedClass {
 // CHECK: swift::Int ExposedStruct2::getProp3() const {
 // CHECK: void ExposedStruct2::renamedMethod() const {
 
+// CHECK-NOT: NonExposedStruct
+