Merge pull request #60785 from hyp/eng/string-to-nsstring

[interop][SwiftToCxx] experimentally expose Swift::String type to C++

Author: hyp

lib/PrintAsClang/ClangSyntaxPrinter.cpp

@@ -98,10 +98,23 @@ void ClangSyntaxPrinter::printExternC(
   os << "#endif\n";
 }
 
+void ClangSyntaxPrinter::printObjCBlock(
+    llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const {
+  os << "#if defined(__OBJC__)\n";
+  bodyPrinter(os);
+  os << "\n#endif\n";
+}
+
 void ClangSyntaxPrinter::printSwiftImplQualifier() const {
   os << "swift::" << cxx_synthesis::getCxxImplNamespaceName() << "::";
 }
 
+void ClangSyntaxPrinter::printInlineForThunk() const {
+  // FIXME: make a macro and add 'nodebug', and
+  // migrate all other 'inline' uses.
+  os << "inline __attribute__((always_inline)) ";
+}
+
 void ClangSyntaxPrinter::printNullability(
     Optional<OptionalTypeKind> kind, NullabilityPrintKind printKind) const {
   if (!kind)

lib/PrintAsClang/ClangSyntaxPrinter.h

@@ -70,6 +70,10 @@ class ClangSyntaxPrinter {
   void
   printExternC(llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const;
 
+  /// Print an #ifdef __OBJC__ block.
+  void
+  printObjCBlock(llvm::function_ref<void(raw_ostream &OS)> bodyPrinter) const;
+
   /// Print the `swift::_impl::` namespace qualifier.
   void printSwiftImplQualifier() const;
 
@@ -80,6 +84,8 @@ class ClangSyntaxPrinter {
     ContextSensitive,
   };
 
+  void printInlineForThunk() const;
+
   void printNullability(
       Optional<OptionalTypeKind> kind,
       NullabilityPrintKind printKind = NullabilityPrintKind::After) const;

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";
@@ -2394,6 +2397,11 @@ static bool isAsyncAlternativeOfOtherDecl(const ValueDecl *VD) {
 }
 
 static bool hasExposeAttr(const ValueDecl *VD) {
+  if (isa<NominalTypeDecl>(VD) && VD->getModuleContext()->isStdlibModule()) {
+    if (VD == VD->getASTContext().getStringDecl())
+      return true;
+    return false;
+  }
   if (VD->getAttrs().hasAttribute<ExposeAttr>())
     return true;
   if (const auto *NMT = dyn_cast<NominalTypeDecl>(VD->getDeclContext()))

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

lib/PrintAsClang/PrintClangValueType.cpp

@@ -87,6 +87,30 @@ void ClangValueTypePrinter::forwardDeclType(raw_ostream &os,
   os << ";\n";
 }
 
+static void addCppExtensionsToStdlibType(const NominalTypeDecl *typeDecl,
+                                         ClangSyntaxPrinter &printer,
+                                         raw_ostream &cPrologueOS) {
+  if (typeDecl == typeDecl->getASTContext().getStringDecl()) {
+    // Perform String -> NSString conversion using
+    // _bridgeToObjectiveCImpl.
+    // FIXME: This is an extension, we should
+    // just expose the method to C once extensions are
+    // supported.
+    cPrologueOS << "SWIFT_EXTERN void *_Nonnull "
+                   "$sSS23_bridgeToObjectiveCImplyXlyF(swift_interop_stub_"
+                   "Swift_String) SWIFT_NOEXCEPT SWIFT_CALL;\n";
+    printer.printObjCBlock([](raw_ostream &os) {
+      os << "  ";
+      ClangSyntaxPrinter(os).printInlineForThunk();
+      os << "operator NSString * _Nonnull () const noexcept {\n";
+      os << "    return (__bridge_transfer NSString "
+            "*)(_impl::$sSS23_bridgeToObjectiveCImplyXlyF(_impl::swift_interop_"
+            "passDirect_Swift_String(_getOpaquePointer())));\n";
+      os << "  }\n";
+    });
+  }
+}
+
 void ClangValueTypePrinter::printValueTypeDecl(
     const NominalTypeDecl *typeDecl,
     llvm::function_ref<void(void)> bodyPrinter) {
@@ -193,6 +217,8 @@ void ClangValueTypePrinter::printValueTypeDecl(
   os << " &&) = default;\n";
 
   bodyPrinter();
+  if (typeDecl->isStdlibDecl())
+    addCppExtensionsToStdlibType(typeDecl, printer, cPrologueOS);
 
   os << "private:\n";
 

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
+

test/Interop/SwiftToCxx/lit.local.cfg

@@ -1 +1 @@
-config.suffixes = ['.swift', '.cpp']
+config.suffixes = ['.swift', '.cpp', '.mm']