Merge pull request #60079 from Robertorosmaninho/cxx-interop/SwiftToCxxErrorHandling

[Interop] [SwiftToCxx] Implementing a naive exception to be thrown in C++ if an Error is thrown in Swift

Author: hyp

lib/PrintAsClang/PrintClangFunction.cpp

@@ -433,9 +433,29 @@ void DeclAndTypeClangFunctionPrinter::printCxxThunkBody(
   }
 
   // Primitive values are returned directly without any conversions.
-  os << "  return ";
+  // Assign the function return value to a variable if the function can throw.
+  if (!resultTy->isVoid() && hasThrows)
+    os << "  auto returnValue = ";
+  // If the function doesn't have a return value just call it.
+  else if (resultTy->isVoid() && hasThrows)
+    os << "  ";
+  // If the function can't throw just return its value result.
+  else if (!hasThrows)
+    os << "  return ";
   printCallToCFunc(/*additionalParam=*/None);
   os << ";\n";
+
+  // Create the condition and the statement to throw an exception.
+  if (hasThrows) {
+    os << "  if (opaqueError != nullptr)\n";
+    os << "    throw (swift::_impl::NaiveException(\"Exception\"));\n";
+  }
+
+  // Return the function result value if it doesn't throw.
+  if (!resultTy->isVoid() && hasThrows) {
+    os << "\n";
+    os << "return returnValue;\n";
+  }
 }
 
 void DeclAndTypeClangFunctionPrinter::printCxxMethod(

lib/PrintAsClang/PrintSwiftToClangCoreScaffold.cpp

@@ -210,6 +210,27 @@ static void printSwiftResilientStorageClass(raw_ostream &os) {
   os << "};\n";
 }
 
+void printCxxNaiveException(raw_ostream &os) {
+  os << "\n";
+  os << "/// Naive exception class that should be thrown\n";
+  os << "class NaiveException {\n";
+  os << "public:\n";
+  os << "  inline NaiveException(const char * _Nonnull msg) noexcept : "
+     << "msg_(msg) { }\n";
+  os << "  inline NaiveException(NaiveException&& other) noexcept : "
+        "msg_(other.msg_) { other.msg_ = nullptr; }\n";
+  os << "  inline ~NaiveException() noexcept { }\n";
+  os << "  void operator =(NaiveException&& other) noexcept { auto temp = msg_;"
+     << " msg_ = other.msg_; other.msg_ = temp; }\n";
+  os << "  void operator =(const NaiveException&) noexcept = delete;";
+  os << "\n";
+  os << "  inline const char * _Nonnull getMessage() const noexcept { "
+     << "return(msg_); }\n";
+  os << "private:\n";
+  os << "  const char * _Nonnull msg_;\n";
+  os << "};\n";
+}
+
 void swift::printSwiftToClangCoreScaffold(SwiftToClangInteropContext &ctx,
                                           PrimitiveTypeMapping &typeMapping,
                                           raw_ostream &os) {
@@ -226,6 +247,7 @@ void swift::printSwiftToClangCoreScaffold(SwiftToClangInteropContext &ctx,
           printOpaqueAllocFee(os);
           os << "\n";
           printSwiftResilientStorageClass(os);
+          printCxxNaiveException(os);
         });
   });
 }

test/Interop/SwiftToCxx/core/swift-impl-defs-in-cxx.swift

@@ -106,6 +106,19 @@
 // CHECK-NEXT:   char * _Nullable storage;
 // CHECK-NEXT: };
 // CHECK-EMPTY:
+// CHECK-NEXT: /// Naive exception class that should be thrown
+// CHECK-NEXT: class NaiveException {
+// CHECK-NEXT: public:
+// CHECK-NEXT: inline NaiveException(const char * _Nonnull msg) noexcept : msg_(msg) { }
+// CHECK-NEXT: inline NaiveException(NaiveException&& other) noexcept : msg_(other.msg_) { other.msg_ = nullptr; }
+// CHECK-NEXT: inline ~NaiveException() noexcept { }
+// CHECK-NEXT: void operator =(NaiveException&& other) noexcept { auto temp = msg_; msg_ = other.msg_; other.msg_ = temp; }
+// CHECK-NEXT: void operator =(const NaiveException&) noexcept = delete;
+// CHECK-NEXT: inline const char * _Nonnull getMessage() const noexcept { return(msg_); }
+// CHECK-NEXT: private:
+// CHECK-NEXT: const char * _Nonnull msg_;
+// CHECK-NEXT: };
+// CHECK-EMPTY:
 // CHECK-NEXT: } // namespace _impl
 // CHECK-EMPTY:
 // CHECK-EMPTY:

test/Interop/SwiftToCxx/functions/swift-functions-errors-execution.cpp

@@ -11,16 +11,35 @@
 // REQUIRES: executable_test
 
 #include <cassert>
+#include <cstdio>
 #include "functions.h"
 
 int main() {
   static_assert(!noexcept(Functions::emptyThrowFunction()), "noexcept function");
   static_assert(!noexcept(Functions::throwFunction()), "noexcept function");
+  static_assert(!noexcept(Functions::throwFunctionWithReturn()), "noexcept function");
+
+  try {
+    Functions::emptyThrowFunction();
+  } catch (swift::_impl::NaiveException& e) {
+    printf("%s\n", e.getMessage());
+  }
+  try {
+    Functions::throwFunction();
+  } catch (swift::_impl::NaiveException& e) {
+    printf("%s\n", e.getMessage());
+  }
+  try {
+    Functions::throwFunctionWithReturn();
+  } catch (swift::_impl::NaiveException& e) {
+    printf("%s\n", e.getMessage());
+  }
 
-  Functions::emptyThrowFunction();
-  Functions::throwFunction();
   return 0;
 }
 
 // CHECK: passEmptyThrowFunction
 // CHECK-NEXT: passThrowFunction
+// CHECK-NEXT: Exception
+// CHECK-NEXT: passThrowFunctionWithReturn
+// CHECK-NEXT: Exception

test/Interop/SwiftToCxx/functions/swift-functions-errors.swift

@@ -23,7 +23,9 @@ public func emptyThrowFunction() throws { print("passEmptyThrowFunction") }
 // CHECK: inline void emptyThrowFunction() {
 // CHECK: void* opaqueError = nullptr;
 // CHECK: void* self = nullptr;
-// CHECK: return _impl::$s9Functions18emptyThrowFunctionyyKF(self, &opaqueError);
+// CHECK: _impl::$s9Functions18emptyThrowFunctionyyKF(self, &opaqueError);
+// CHECK: if (opaqueError != nullptr)
+// CHECK: throw (swift::_impl::NaiveException("Exception"));
 // CHECK: }
 
 public func throwFunction() throws {
@@ -34,5 +36,22 @@ public func throwFunction() throws {
 // CHECK: inline void throwFunction() {
 // CHECK: void* opaqueError = nullptr;
 // CHECK: void* self = nullptr;
-// CHECK: return _impl::$s9Functions13throwFunctionyyKF(self, &opaqueError);
+// CHECK: _impl::$s9Functions13throwFunctionyyKF(self, &opaqueError);
+// CHECK: if (opaqueError != nullptr)
+// CHECK: throw (swift::_impl::NaiveException("Exception"));
 // CHECK: }
+
+public func throwFunctionWithReturn() throws -> Int {
+    print("passThrowFunctionWithReturn")
+    throw NaiveErrors.returnError
+    return 0
+}
+
+// CHECK: inline swift::Int throwFunctionWithReturn() SWIFT_WARN_UNUSED_RESULT {
+// CHECK: void* opaqueError = nullptr;
+// CHECK: void* self = nullptr;
+// CHECK: auto returnValue = _impl::$s9Functions23throwFunctionWithReturnSiyKF(self, &opaqueError);
+// CHECK: if (opaqueError != nullptr)
+// CHECK: throw (swift::_impl::NaiveException("Exception"));
+// CHECK: return returnValue;
+// CHECK: }