[interop][SwiftToCxx] generics: add support for returning primitive generic types

Author: hyp

lib/PrintAsClang/PrintClangFunction.cpp

@@ -66,6 +66,8 @@ bool isResilientType(Type t) {
   return false;
 }
 
+bool isGenericType(Type t) { return t->is<GenericTypeParamType>(); }
+
 bool isKnownCxxType(Type t, PrimitiveTypeMapping &typeMapping) {
   return isKnownType(t, typeMapping, OutputLanguageMode::Cxx);
 }
@@ -223,7 +225,12 @@ class CFunctionSignatureTypePrinter
                                  Optional<OptionalTypeKind> optionalKind,
                                  bool isInOutParam) {
     // FIXME: handle optionalKind.
-    // FIXME: handle isInOutParam.
+    if (typeUseKind == FunctionSignatureTypeUse::ReturnType) {
+      // generic is always returned indirectly in C signature.
+      assert(languageMode == OutputLanguageMode::Cxx);
+      os << genericTpt->getName();
+      return;
+    }
     if (!isInOutParam)
       os << "const ";
     if (languageMode == OutputLanguageMode::Cxx) {
@@ -321,7 +328,7 @@ void DeclAndTypeClangFunctionPrinter::printFunctionSignature(
   bool isIndirectReturnType =
       kind == FunctionSignatureKind::CFunctionProto &&
       !isKnownCType(resultTy, typeMapping) &&
-      (isResilientType(resultTy) ||
+      (isResilientType(resultTy) || isGenericType(resultTy) ||
        interopContext.getIrABIDetails().shouldReturnIndirectly(resultTy));
   if (!isIndirectReturnType) {
     OptionalTypeKind retKind;
@@ -542,6 +549,16 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
   // indirectly by a pointer.
   if (!isKnownCxxType(resultTy, typeMapping) &&
       !hasKnownOptionalNullableCxxMapping(resultTy)) {
+    if (isGenericType(resultTy)) {
+      // FIXME: Support returning value types.
+      os << "  T returnValue;\n";
+      std::string returnAddress;
+      llvm::raw_string_ostream ros(returnAddress);
+      ros << "reinterpret_cast<void *>(&returnValue)";
+      printCallToCFunc(/*additionalParam=*/StringRef(ros.str()));
+      os << ";\n  return returnValue;\n";
+      return;
+    }
     if (auto *decl = resultTy->getNominalOrBoundGenericNominal()) {
       if ((isa<StructDecl>(decl) || isa<EnumDecl>(decl))) {
         bool isIndirect =

test/Interop/SwiftToCxx/generics/generic-function-execution.cpp

@@ -116,5 +116,15 @@ int main() {
     assert(x == -13);
     assert(y == 42);
   }
+
+  {
+    int x = 4;
+    assert(genericRet(x) == 4);
+  }
+
+  {
+    double x = -19.75;
+    assert(genericRet(x) == -19.75);
+  }
   return 0;
 }

test/Interop/SwiftToCxx/generics/generic-function-in-cxx.swift

@@ -27,9 +27,14 @@ public func genericSwap<T>(_ x: inout T, _ y: inout T) {
   y = t
 }
 
+public func genericRet<T>(_ x: T) -> T {
+    return x
+}
+
 // CHECK: SWIFT_EXTERN void $s9Functions20genericPrintFunctionyyxlF(const void * _Nonnull x, void * _Nonnull ) SWIFT_NOEXCEPT SWIFT_CALL; // genericPrintFunction(_:)
 // CHECK-NEXT: SWIFT_EXTERN void $s9Functions32genericPrintFunctionMultiGenericyySi_xxSiq_tr0_lF(ptrdiff_t x, const void * _Nonnull t1, const void * _Nonnull t1p, ptrdiff_t y, const void * _Nonnull t2, void * _Nonnull , void * _Nonnull ) SWIFT_NOEXCEPT SWIFT_CALL; // genericPrintFunctionMultiGeneric(_:_:_:_:_:)
 // CHECK-NEXT: SWIFT_EXTERN void $s9Functions26genericPrintFunctionTwoArgyyx_SitlF(const void * _Nonnull x, ptrdiff_t y, void * _Nonnull ) SWIFT_NOEXCEPT SWIFT_CALL; // genericPrintFunctionTwoArg(_:_:)
+// CHECK-NEXT: SWIFT_EXTERN void $s9Functions10genericRetyxxlF(SWIFT_INDIRECT_RESULT void * _Nonnull, const void * _Nonnull x, void * _Nonnull ) SWIFT_NOEXCEPT SWIFT_CALL; // genericRet(_:)
 // CHECK-NEXT: SWIFT_EXTERN void $s9Functions11genericSwapyyxz_xztlF(void * _Nonnull x, void * _Nonnull y, void * _Nonnull ) SWIFT_NOEXCEPT SWIFT_CALL; // genericSwap(_:_:)
 
 // CHECK:      template<class T>
@@ -52,6 +57,14 @@ public func genericSwap<T>(_ x: inout T, _ y: inout T) {
 // CHECK-NEXT:   return _impl::$s9Functions26genericPrintFunctionTwoArgyyx_SitlF(reinterpret_cast<const void *>(&x), y, swift::getTypeMetadata<T>());
 // CHECK-NEXT: }
 
+// CHECK:      template<class T>
+// CHECK-NEXT: requires swift::isUsableInGenericContext<T>
+// CHECK-NEXT: inline T genericRet(const T & x) noexcept SWIFT_WARN_UNUSED_RESULT {
+// CHECK-NEXT:   T returnValue;
+// CHECK-NEXT: _impl::$s9Functions10genericRetyxxlF(reinterpret_cast<void *>(&returnValue), reinterpret_cast<const void *>(&x), swift::getTypeMetadata<T>());
+// CHECK-NEXT:   return returnValue;
+// CHECK-NEXT: }
+
 // CHECK:      template<class T>
 // CHECK-NEXT: requires swift::isUsableInGenericContext<T>
 // CHECK-NEXT: inline void genericSwap(T & x, T & y) noexcept {