Flesh out exception handling and tests.

kring · kring · commit e31a45bc30a6 · 2025-01-24T23:06:20.000+11:00
diff --git a/Reinterop~/CSharpReinteropException.cs b/Reinterop~/CSharpReinteropException.cs
@@ -14,6 +14,21 @@ public static void Generate(GeneratorExecutionContext context)
             context.AddSource("ReinteropException", Source);
         }
 
+        public static CppType GetCppWrapperType(CppGenerationContext context)
+        {
+            List<string> ns = new List<string>();
+            if (context.BaseNamespace.Length > 0)
+                ns.Add(context.BaseNamespace);
+            ns.Add("Reinterop");
+
+            // If the first two namespaces are identical, remove the duplication.
+            // This is to avoid `Reinterop::Reinterop`.
+            if (ns.Count >= 2 && ns[0] == ns[1])
+                ns.RemoveAt(0);
+
+            return new CppType(InteropTypeKind.ClassWrapper, ns, "ReinteropException", null, 0);
+        }
+
         public const string Source =
             """
             namespace Reinterop
@@ -26,6 +41,7 @@ public ReinteropException(string message) : base(message) {}
                     internal static void ExposeToCPP()
                     {
                         ReinteropException e = new ReinteropException("message");
+                        string s = e.Message;
                     }
                 }
             }
diff --git a/Reinterop~/CppReinteropException.cs b/Reinterop~/CppReinteropException.cs
@@ -14,7 +14,7 @@ public static CppType GetCppType(CppGenerationContext context)
             if (ns.Count >= 2 && ns[0] == ns[1])
                 ns.RemoveAt(0);
 
-            return new CppType(InteropTypeKind.ClassWrapper, ns, "ReinteropException", null, 0);
+            return new CppType(InteropTypeKind.ClassWrapper, ns, "ReinteropNativeException", null, 0);
         }
 
         public static void Generate(CppGenerationContext context, IDictionary<string, CppSourceFile> sourceFiles)
@@ -35,9 +35,9 @@ public static void Generate(CppGenerationContext context, IDictionary<string, Cp
             var headerNamespace = headerFile.GetNamespace(type.GetFullyQualifiedNamespace(false));
             headerNamespace.Members.Add(
                 $$"""
-                class ReinteropException : public std::runtime_error {
+                class ReinteropNativeException : public std::runtime_error {
                 public:
-                  ReinteropException(const DotNet::System::Exception& exception);
+                  ReinteropNativeException(const DotNet::System::Exception& exception);
                   const ::DotNet::System::Exception& GetDotNetException() const;
                 
                 private:
@@ -69,11 +69,11 @@ class ReinteropException : public std::runtime_error {
             var sourceNamespace = sourceFile.GetNamespace(type.GetFullyQualifiedNamespace(false));
             sourceNamespace.Members.Add(
                 $$"""
-                ReinteropException::ReinteropException(const DotNet::System::Exception& exception)
+                ReinteropNativeException::ReinteropNativeException(const DotNet::System::Exception& exception)
                     : std::runtime_error(exception.Message().ToStlString()),
                     _exception(exception) {}
                 
-                const ::DotNet::System::Exception& ReinteropException::GetDotNetException() const {
+                const ::DotNet::System::Exception& ReinteropNativeException::GetDotNetException() const {
                     return this->_exception;
                 }
                 """);
diff --git a/Reinterop~/Methods.cs b/Reinterop~/Methods.cs
@@ -236,7 +236,7 @@ public static void GenerateSingleMethod(CppGenerationContext context, TypeToGene
                             void* reinteropException = nullptr;
                             {{interopName}}({{string.Join(", ", parameterPassStrings)}});
                             if (reinteropException != nullptr)
-                                throw Reinterop::ReinteropException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
+                                throw Reinterop::ReinteropNativeException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
                         }
                         """,
                     TypeDefinitionsReferenced: new[]
@@ -280,7 +280,7 @@ public static void GenerateSingleMethod(CppGenerationContext context, TypeToGene
                             void* reinteropException = nullptr;
                             {{GenerationUtility.JoinAndIndent(invocation, "    ")}}
                             if (reinteropException != nullptr)
-                                throw Reinterop::ReinteropException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
+                                throw Reinterop::ReinteropNativeException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
                             {{returnStatement}}
                         }
                         """,
diff --git a/Reinterop~/MethodsImplementedInCpp.cs b/Reinterop~/MethodsImplementedInCpp.cs
@@ -339,7 +339,7 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
                       try {
                         {{GenerationUtility.JoinAndIndent(new[] { getCallTarget }, "    ")}}
                         {{new[] { implementation }.JoinAndIndent("    ")}}
-                      } catch (::DotNet::Reinterop::ReinteropException& e) {
+                      } catch (::DotNet::Reinterop::ReinteropNativeException& e) {
                         *reinteropException = ::DotNet::Reinterop::ObjectHandle(e.GetDotNetException().GetHandle()).Release();
                         {{returnDefault}}
                       } catch (std::exception& e) {
@@ -357,7 +357,9 @@ private static void GenerateMethod(CppGenerationContext context, TypeToGenerate
                     implType,
                     returnType,
                     objectHandleType,
-                    CppReinteropException.GetCppType(context)
+                    CppReinteropException.GetCppType(context),
+                    CSharpReinteropException.GetCppWrapperType(context),
+                    CppType.FromCSharp(context, context.Compilation.GetSpecialType(SpecialType.System_String))
                 }.Concat(parameters.Select(parameter => parameter.Type))
                  .Concat(parameters.Select(parameter => parameter.InteropType)),
                 AdditionalIncludes: hasStructRewrite ? new[] { "<utility>" } : null // for std::move
diff --git a/Reinterop~/Properties.cs b/Reinterop~/Properties.cs
@@ -100,7 +100,7 @@ private static void GenerateSingleMethod(CppGenerationContext context, TypeToGen
 
             // Method definition
             var parameterPassStrings = interopParameters.Select(parameter => parameter.Type.GetConversionToInteropType(context, parameter.CallSiteName));
-            parameterPassStrings = parameterPassStrings.Concat(new[] {"&reinteropException"}).Where(s => !string.IsNullOrEmpty(s));
+            parameterPassStrings = parameterPassStrings.Concat(new[] { "&reinteropException" }).Where(s => !string.IsNullOrEmpty(s));
             if (returnType.Name == "void" && !returnType.Flags.HasFlag(CppTypeFlags.Pointer))
             {
                 definition.Elements.Add(new(
@@ -110,7 +110,7 @@ private static void GenerateSingleMethod(CppGenerationContext context, TypeToGen
                             void* reinteropException = nullptr;
                             Property_{{method.Name}}({{string.Join(", ", parameterPassStrings)}});
                             if (reinteropException != nullptr)
-                                throw Reinterop::ReinteropException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
+                                throw Reinterop::ReinteropNativeException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
                         }
                         """,
                     TypeDefinitionsReferenced: new[]
@@ -140,7 +140,7 @@ private static void GenerateSingleMethod(CppGenerationContext context, TypeToGen
                             void* reinteropException = nullptr;
                             {{GenerationUtility.JoinAndIndent(invocation, "    ")}}
                             if (reinteropException != nullptr)
-                                throw Reinterop::ReinteropException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
+                                throw Reinterop::ReinteropNativeException(::DotNet::System::Exception(::DotNet::Reinterop::ObjectHandle(reinteropException)));
                             return {{returnType.GetConversionFromInteropType(context, "result")}};
                         }
                         """,
diff --git a/Reinterop~/RoslynSourceGenerator.cs b/Reinterop~/RoslynSourceGenerator.cs
@@ -36,7 +36,10 @@ public void Execute(GeneratorExecutionContext context)
             // Create a new Compilation with the CSharpObjectHandleUtility created above.
             // Newer versions of Roslyn make this easy, but not the one in Unity.
             CSharpParseOptions options = (CSharpParseOptions)((CSharpCompilation)context.Compilation).SyntaxTrees[0].Options;
-            Compilation compilation = context.Compilation.AddSyntaxTrees(CSharpSyntaxTree.ParseText(SourceText.From(CSharpObjectHandleUtility.Source), options));
+            Compilation compilation = context.Compilation.AddSyntaxTrees(
+                CSharpSyntaxTree.ParseText(SourceText.From(CSharpObjectHandleUtility.Source), options),
+                CSharpSyntaxTree.ParseText(SourceText.From(CSharpReinteropException.Source), options)
+            );
 
             // Add ObjectHandleUtility's ExposeToCPP to the receiver.
             INamedTypeSymbol? objectHandleUtilityType = compilation.GetTypeByMetadataName("Reinterop.ObjectHandleUtility");
@@ -59,6 +62,27 @@ public void Execute(GeneratorExecutionContext context)
                 }
             }
 
+            // Add ReinteropExceptions's ExposeToCPP to the receiver.
+            INamedTypeSymbol? reinteropExceptionType = compilation.GetTypeByMetadataName("Reinterop.ReinteropException");
+            if (reinteropExceptionType != null)
+            {
+                var exposeToCpp = CSharpTypeUtility.FindMembers(reinteropExceptionType, "ExposeToCPP");
+                foreach (ISymbol symbol in exposeToCpp)
+                {
+                    IMethodSymbol? method = symbol as IMethodSymbol;
+                    if (method == null)
+                        continue;
+
+                    foreach (var reference in method.DeclaringSyntaxReferences)
+                    {
+                        if (reference.GetSyntax() is MethodDeclarationSyntax methodDeclaration)
+                        {
+                            receiver.ExposeToCppMethods.Add(methodDeclaration);
+                        }
+                    }
+                }
+            }
+
             Dictionary<string, object> properties = new Dictionary<string, object>();
             foreach (var property in receiver.Properties)
             {
diff --git a/Runtime/TestReinterop.cs b/Runtime/TestReinterop.cs
@@ -10,6 +10,8 @@ internal partial class TestReinterop
     {
         public partial bool CallThrowAnExceptionFromCppAndCatchIt();
         public partial bool CallThrowAnExceptionFromCppAndDontCatchIt();
+        public partial bool ThrowCppStdException();
+        public partial bool ThrowOtherCppExceptionType();
 
         public static void ThrowAnException()
         {
diff --git a/Tests/TestReinterop.cs b/Tests/TestReinterop.cs
@@ -13,11 +13,41 @@ public void TestADotNetExceptionCanBeCaughtInCpp()
     public void TestADotNetExceptionCanPropagateThroughCpp()
     {
         CesiumForUnity.TestReinterop o = new CesiumForUnity.TestReinterop();
-        try {
+        try
+        {
             o.CallThrowAnExceptionFromCppAndDontCatchIt();
-        } catch (System.Exception e)
+        }
+        catch (System.Exception e)
         {
             Assert.AreEqual("Test Exception!", e.Message);
         }
     }
+
+    [Test]
+    public void TestACppStdExceptionCanBeCaughtInCSharp()
+    {
+        CesiumForUnity.TestReinterop o = new CesiumForUnity.TestReinterop();
+        try
+        {
+            o.ThrowCppStdException();
+        }
+        catch (System.Exception e)
+        {
+            Assert.AreEqual("An exceptional hello from C++!", e.Message);
+        }
+    }
+
+    [Test]
+    public void TestAGeneralCppExceptionCanBeCaughtInCSharp()
+    {
+        CesiumForUnity.TestReinterop o = new CesiumForUnity.TestReinterop();
+        try
+        {
+            o.ThrowOtherCppExceptionType();
+        }
+        catch (System.Exception e)
+        {
+            Assert.AreEqual("An unknown native exception occurred.", e.Message);
+        }
+    }
 }
diff --git a/native~/Runtime/src/TestReinteropImpl.cpp b/native~/Runtime/src/TestReinteropImpl.cpp
@@ -2,6 +2,8 @@
 
 #include <DotNet/CesiumForUnity/TestReinterop.h>
 
+#include <stdexcept>
+
 namespace CesiumForUnityNative {
 
 bool TestReinteropImpl::CallThrowAnExceptionFromCppAndCatchIt(
@@ -21,4 +23,14 @@ bool TestReinteropImpl::CallThrowAnExceptionFromCppAndDontCatchIt(
   return false;
 }
 
+bool TestReinteropImpl::ThrowCppStdException(
+    const DotNet::CesiumForUnity::TestReinterop& instance) {
+  throw std::exception("An exceptional hello from C++!");
+}
+
+bool TestReinteropImpl::ThrowOtherCppExceptionType(
+    const DotNet::CesiumForUnity::TestReinterop& instance) {
+  throw "This is a dodgy exception.";
+}
+
 } // namespace CesiumForUnityNative
diff --git a/native~/Runtime/src/TestReinteropImpl.h b/native~/Runtime/src/TestReinteropImpl.h
@@ -14,6 +14,10 @@ class TestReinteropImpl {
       const DotNet::CesiumForUnity::TestReinterop& instance);
   static bool CallThrowAnExceptionFromCppAndDontCatchIt(
       const DotNet::CesiumForUnity::TestReinterop& instance);
+  static bool
+  ThrowCppStdException(const DotNet::CesiumForUnity::TestReinterop& instance);
+  static bool ThrowOtherCppExceptionType(
+      const DotNet::CesiumForUnity::TestReinterop& instance);
 };
 
 } // namespace CesiumForUnityNative

Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,21 @@ public static void Generate(GeneratorExecutionContext context)`
`14`	`14`	`context.AddSource("ReinteropException", Source);`
`15`	`15`	`}`
`16`	`16`
	`17`	`+ public static CppType GetCppWrapperType(CppGenerationContext context)`
	`18`	`+ {`
	`19`	`+ List<string> ns = new List<string>();`
	`20`	`+ if (context.BaseNamespace.Length > 0)`
	`21`	`+ ns.Add(context.BaseNamespace);`
	`22`	`+ ns.Add("Reinterop");`
	`23`	`+`
	`24`	`+ // If the first two namespaces are identical, remove the duplication.`
	`25`	+ // This is to avoid `Reinterop::Reinterop`.
	`26`	`+ if (ns.Count >= 2 && ns[0] == ns[1])`
	`27`	`+ ns.RemoveAt(0);`
	`28`	`+`
	`29`	`+ return new CppType(InteropTypeKind.ClassWrapper, ns, "ReinteropException", null, 0);`
	`30`	`+ }`
	`31`	`+`
`17`	`32`	`public const string Source =`
`18`	`33`	`"""`
`19`	`34`	`namespace Reinterop`
`@@ -26,6 +41,7 @@ public ReinteropException(string message) : base(message) {}`
`26`	`41`	`internal static void ExposeToCPP()`
`27`	`42`	`{`
`28`	`43`	`ReinteropException e = new ReinteropException("message");`
	`44`	`+ string s = e.Message;`
`29`	`45`	`}`
`30`	`46`	`}`
`31`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,8 @@ internal partial class TestReinterop`
`10`	`10`	`{`
`11`	`11`	`public partial bool CallThrowAnExceptionFromCppAndCatchIt();`
`12`	`12`	`public partial bool CallThrowAnExceptionFromCppAndDontCatchIt();`
	`13`	`+ public partial bool ThrowCppStdException();`
	`14`	`+ public partial bool ThrowOtherCppExceptionType();`
`13`	`15`
`14`	`16`	`public static void ThrowAnException()`
`15`	`17`	`{`