Propagate C++ exceptions back to C#.

CesiumGS · Jan 24, 2025 · b5da340 · b5da340
1 parent 5cc7921
commit b5da340
Show file tree

Hide file tree

Showing 7 changed files with 92 additions and 8 deletions.
diff --git a/Reinterop~/CSharpReinteropException.cs b/Reinterop~/CSharpReinteropException.cs
@@ -0,0 +1,34 @@
+using Microsoft.CodeAnalysis;
+
+namespace Reinterop
+{
+    /// <summary>
+    /// Inserts the "ReinteropException" class into an assembly as it is compiled.
+    /// This is intended to be used from a RegisterPostInitializationOutput
+    /// callback on an IIncrementalGenerator.
+    /// </summary>
+    internal class CSharpReinteropException
+    {
+        public static void Generate(GeneratorExecutionContext context)
+        {
+            context.AddSource("ReinteropException", Source);
+        }
+
+        public const string Source =
+            """
+            namespace Reinterop
+            {
+                [Reinterop]
+                internal class ReinteropException : System.Exception
+                {
+                    public ReinteropException(string message) : base(message) {}
+
+                    internal static void ExposeToCPP()
+                    {
+                        ReinteropException e = new ReinteropException("message");
+                    }
+                }
+            }
+            """;
+    }
+}
diff --git a/Reinterop~/MethodsImplementedInCpp.cs b/Reinterop~/MethodsImplementedInCpp.cs
@@ -300,7 +300,7 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
             var parameterList = parameters.Select(parameter => $"{parameter.InteropType.GetFullyQualifiedName()} {parameter.ParameterName}");
             var callParameterList = parameters.Where(parameter => parameter.CallSiteName.Length > 0).Select(parameter => parameter.Type.GetConversionFromInteropType(context, parameter.CallSiteName));
 
-            string parameterListString = string.Join(", ", parameterList);
+            string parameterListString = string.Join(", ", parameterList.Concat(new[] {"void** reinteropException"}));
             string callParameterListString = string.Join(", ", callParameterList);
 
             string implementation;
@@ -320,23 +320,44 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
                     """;
             }
 
+            string returnDefault = "";
+            if (interopReturnType != CppType.Void)
+            {
+                if (interopReturnType.Flags.HasFlag(CppTypeFlags.Pointer))
+                    returnDefault = "return nullptr;";
+                else
+                    returnDefault = $$"""return {{interopReturnType.GetFullyQualifiedName()}}();""";
+            }
+
             result.CppImplementationInvoker.Functions.Add(new(
                 Content:
                     $$"""
                     #if defined(_WIN32)
                     __declspec(dllexport)
                     #endif
                     {{interopReturnType.GetFullyQualifiedName()}} {{name}}({{parameterListString}}) {
-                      {{GenerationUtility.JoinAndIndent(new[] { getCallTarget }, "  ")}}
-                      {{new[] { implementation }.JoinAndIndent("  ")}}
+                      try {
+                        {{GenerationUtility.JoinAndIndent(new[] { getCallTarget }, "    ")}}
+                        {{new[] { implementation }.JoinAndIndent("    ")}}
+                      } catch (::DotNet::Reinterop::ReinteropException& e) {
+                        *reinteropException = ::DotNet::Reinterop::ObjectHandle(e.GetDotNetException().GetHandle()).Release();
+                        {{returnDefault}}
+                      } catch (std::exception& e) {
+                        *reinteropException = ::DotNet::Reinterop::ReinteropException(::DotNet::System::String(e.what())).GetHandle().Release();
+                        {{returnDefault}}
+                      } catch (...) {
+                        *reinteropException = ::DotNet::Reinterop::ReinteropException(::DotNet::System::String("An unknown native exception occurred.")).GetHandle().Release();
+                        {{returnDefault}}
+                      }                   
                     }
                     """,
                 TypeDefinitionsReferenced: new[]
                 {
                     wrapperType,
                     implType,
                     returnType,
-                    objectHandleType
+                    objectHandleType,
+                    CppReinteropException.GetCppType(context)
                 }.Concat(parameters.Select(parameter => parameter.Type))
                  .Concat(parameters.Select(parameter => parameter.InteropType)),
                 AdditionalIncludes: hasStructRewrite ? new[] { "<utility>" } : null // for std::move
@@ -375,6 +396,10 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
                 csInteropReturnType = CSharpType.FromSymbol(context, returnType.Kind == InteropTypeKind.Nullable ? context.Compilation.GetSpecialType(SpecialType.System_Byte) : context.Compilation.GetSpecialType(SpecialType.System_Void));
             }
 
+            // Add a parameter in which to receive an exception from the C++ side.
+            CSharpType exceptionPtr = CSharpType.FromSymbol(context, context.Compilation.GetSpecialType(SpecialType.System_IntPtr)).AsPointer();
+            csParametersInterop = csParametersInterop.Concat(new[] { (Name: "reinteropException", CallName: "&reinteropException", Type: exceptionPtr, IsParams: false) });
+
             List<string> csImplementationLines = new List<string>();
             if (hasStructRewrite)
             {
@@ -386,6 +411,8 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
             else
                 csImplementationLines.Add($"var result = {name}({string.Join(", ", csParametersInterop.Select(parameter => parameter.Type.GetConversionToInteropType(parameter.CallName)))});");
 
+            csImplementationLines.Add("if (reinteropException != IntPtr.Zero) throw (System.Exception)Reinterop.ObjectHandleUtility.GetObjectAndFreeHandle(reinteropException);");
+
             if (csReturnType.SpecialType != SpecialType.System_Void)
             {
                 if (hasStructRewrite)
@@ -434,6 +461,7 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
                         unsafe
                         {
                             {{GenerationUtility.JoinAndIndent(new[] { implementationCheck }, "        ")}}
+                            System.IntPtr reinteropException = System.IntPtr.Zero;
                             {{csImplementationLines.JoinAndIndent("        ")}}
                         }
                     }

diff --git a/Reinterop~/RoslynSourceGenerator.cs b/Reinterop~/RoslynSourceGenerator.cs
@@ -31,6 +31,7 @@ public void Execute(GeneratorExecutionContext context)
             CSharpReinteropAttribute.Generate(context);
             CSharpReinteropNativeImplementationAttribute.Generate(context);
             CSharpObjectHandleUtility.Generate(context);
+            CSharpReinteropException.Generate(context);
 
             // Create a new Compilation with the CSharpObjectHandleUtility created above.
             // Newer versions of Roslyn make this easy, but not the one in Unity.

diff --git a/Runtime/TestReinterop.cs b/Runtime/TestReinterop.cs
@@ -8,7 +8,8 @@ namespace CesiumForUnity
     [ReinteropNativeImplementation("CesiumForUnityNative::TestReinteropImpl", "TestReinteropImpl.h", true)]
     internal partial class TestReinterop
     {
-        public partial bool CallThrowAnExceptionFromCpp();
+        public partial bool CallThrowAnExceptionFromCppAndCatchIt();
+        public partial bool CallThrowAnExceptionFromCppAndDontCatchIt();
 
         public static void ThrowAnException()
         {

diff --git a/Tests/TestReinterop.cs b/Tests/TestReinterop.cs
@@ -6,6 +6,18 @@ public class TestReinterop
     public void TestADotNetExceptionCanBeCaughtInCpp()
     {
         CesiumForUnity.TestReinterop o = new CesiumForUnity.TestReinterop();
-        Assert.IsTrue(o.CallThrowAnExceptionFromCpp());
+        Assert.IsTrue(o.CallThrowAnExceptionFromCppAndCatchIt());
+    }
+
+    [Test]
+    public void TestADotNetExceptionCanPropagateThroughCpp()
+    {
+        CesiumForUnity.TestReinterop o = new CesiumForUnity.TestReinterop();
+        try {
+            o.CallThrowAnExceptionFromCppAndDontCatchIt();
+        } catch (System.Exception e)
+        {
+            Assert.AreEqual("Test Exception!", e.Message);
+        }
     }
 }
diff --git a/native~/Runtime/src/TestReinteropImpl.cpp b/native~/Runtime/src/TestReinteropImpl.cpp
@@ -4,7 +4,7 @@
 
 namespace CesiumForUnityNative {
 
-bool TestReinteropImpl::CallThrowAnExceptionFromCpp(
+bool TestReinteropImpl::CallThrowAnExceptionFromCppAndCatchIt(
     const DotNet::CesiumForUnity::TestReinterop& instance) {
   try {
     instance.ThrowAnException();
@@ -15,4 +15,10 @@ bool TestReinteropImpl::CallThrowAnExceptionFromCpp(
   return false;
 }
 
+bool TestReinteropImpl::CallThrowAnExceptionFromCppAndDontCatchIt(
+    const DotNet::CesiumForUnity::TestReinterop& instance) {
+  instance.ThrowAnException();
+  return false;
+}
+
 } // namespace CesiumForUnityNative
diff --git a/native~/Runtime/src/TestReinteropImpl.h b/native~/Runtime/src/TestReinteropImpl.h
@@ -10,7 +10,9 @@ namespace CesiumForUnityNative {
 
 class TestReinteropImpl {
 public:
-  static bool CallThrowAnExceptionFromCpp(
+  static bool CallThrowAnExceptionFromCppAndCatchIt(
+      const DotNet::CesiumForUnity::TestReinterop& instance);
+  static bool CallThrowAnExceptionFromCppAndDontCatchIt(
       const DotNet::CesiumForUnity::TestReinterop& instance);
 };