[WIP] Support for nullable structs

Author: Felix Deimel

Generator/Beyond.NET.CodeGenerator/Collectors/TypeCollector.cs

@@ -364,12 +364,25 @@ out string? unsupportedReason
             return false;
         }
 
-        if (type.IsNullableValueType(out Type? nullableValueType)) {
-            unsupportedReason = $"Is Nullable Value Type ({nullableValueType.FullName}?)";
+        bool isNullableValueType = type.IsNullableValueType(out Type? nullableValueType);
+
+        // Only nullable structs, not primitives or enums are currently supported
+        bool isNullableStruct = isNullableValueType &&
+                                (nullableValueType?.IsStruct() ?? false);
+
+        // if (isNullableValueType) {
+        //     unsupportedReason = $"Is Nullable Value Type ({nullableValueType.FullName}?)";
+        //     return false;
+        // }
+        
+        if (isNullableValueType &&
+            !isNullableStruct) {
+            unsupportedReason = $"Is Nullable Value Type, but not a struct ({nullableValueType?.FullName}?)";
             return false;
         }
 
-        if (!m_enableGenericsSupport &&
+        if (!isNullableStruct &&
+            !m_enableGenericsSupport &&
             type.IsGenericInAnyWay(true)) {
             unsupportedReason = "Is Generic (disabled by configuration)";
             return false;
@@ -382,7 +395,8 @@ out string? unsupportedReason
         }
 
         // TODO: Generic Types as arguments, properties, etc.
-        if (type.IsConstructedGenericType) {
+        if (!isNullableValueType &&
+            type.IsConstructedGenericType) {
             Type genericTypeDefinition = type.GetGenericTypeDefinition();
 
             if (UNSUPPORTED_TYPES.Contains(genericTypeDefinition)) {

Generator/Beyond.NET.CodeGenerator/Extensions/TypeExtensions.cs

@@ -84,6 +84,10 @@ internal static string GetFullNameOrName(this Type type)
 
     internal static string CTypeName(this Type type)
     {
+        if (type.IsNullableValueType(out Type? valueType)) {
+            type = valueType;
+        }
+        
         string fullTypeName = type.GetFullNameOrName();
 
         string cTypeName = fullTypeName

Generator/Beyond.NET.CodeGenerator/Syntax/C/CMethodSyntaxWriter.cs

@@ -155,15 +155,21 @@ out string generatedName
                 CodeLanguage.C
             );
         }
+
+        bool isNullableValueTypeReturnType = returnOrSetterOrEventHandlerType.IsNullableValueType(out Type? nullableValueReturnType);
 
-        bool isGenericReturnType = returnOrSetterOrEventHandlerType.IsGenericParameter ||
-                                   returnOrSetterOrEventHandlerType.IsGenericMethodParameter ||
-                                   returnOrSetterOrEventHandlerType.IsGenericType ||
-                                   returnOrSetterOrEventHandlerType.IsGenericTypeDefinition ||
-                                   returnOrSetterOrEventHandlerType.IsGenericTypeParameter ||
-                                   returnOrSetterOrEventHandlerType.IsConstructedGenericType;
-
-        bool isConstructedGenericReturnType = returnOrSetterOrEventHandlerType.IsConstructedGenericType;
+        bool isGenericReturnType = !isNullableValueTypeReturnType &&
+                                   (
+                                       returnOrSetterOrEventHandlerType.IsGenericParameter ||
+                                       returnOrSetterOrEventHandlerType.IsGenericMethodParameter ||
+                                       returnOrSetterOrEventHandlerType.IsGenericType ||
+                                       returnOrSetterOrEventHandlerType.IsGenericTypeDefinition ||
+                                       returnOrSetterOrEventHandlerType.IsGenericTypeParameter ||
+                                       returnOrSetterOrEventHandlerType.IsConstructedGenericType
+                                    );
+
+        bool isConstructedGenericReturnType = !isNullableValueTypeReturnType &&
+                                              returnOrSetterOrEventHandlerType.IsConstructedGenericType;
 
         bool isGenericArrayReturnType = false;
 
@@ -192,10 +198,17 @@ out string generatedName
             }
         }
 
-        bool returnOrSetterOrEventHandlerTypeIsByRef = returnOrSetterOrEventHandlerType.IsByRef;
+        bool returnOrSetterOrEventHandlerTypeIsByRef;
+
+        if (isNullableValueTypeReturnType) {
+            returnOrSetterOrEventHandlerTypeIsByRef = true;
+            returnOrSetterOrEventHandlerType = nullableValueReturnType ?? returnOrSetterOrEventHandlerType;
+        } else {
+            returnOrSetterOrEventHandlerTypeIsByRef = returnOrSetterOrEventHandlerType.IsByRef;
 
-        if (returnOrSetterOrEventHandlerTypeIsByRef) {
-            returnOrSetterOrEventHandlerType = returnOrSetterOrEventHandlerType.GetNonByRefType();
+            if (returnOrSetterOrEventHandlerTypeIsByRef) {
+                returnOrSetterOrEventHandlerType = returnOrSetterOrEventHandlerType.GetNonByRefType();
+            }   
         }
 
         TypeDescriptor returnOrSetterTypeDescriptor = returnOrSetterOrEventHandlerType.GetTypeDescriptor(typeDescriptorRegistry);

Generator/Beyond.NET.CodeGenerator/Syntax/C/CTypeSyntaxWriter.cs

@@ -42,7 +42,8 @@ public string Write(Type type, State state, ISyntaxWriterConfiguration? configur
         // Result cSharpUnmanagedResult = state.CSharpUnmanagedResult ?? throw new Exception("No CSharpUnmanagedResult provided");
 
         if (type.IsPointer ||
-            type.IsByRef) {
+            type.IsByRef ||
+            type.IsNullableValueType(out _)) {
             // No need to generate C code for those kinds of types
 
             return string.Empty;

Generator/Beyond.NET.CodeGenerator/Types/TypeDescriptor.cs

@@ -1,3 +1,4 @@
+using System.Diagnostics.CodeAnalysis;
 using Beyond.NET.CodeGenerator.Extensions;
 
 namespace Beyond.NET.CodeGenerator.Types;
@@ -15,7 +16,12 @@ public class TypeDescriptor
     public bool IsVoid => ManagedType.IsVoid();
     public bool IsDelegate => ManagedType.IsDelegate();
     public bool IsManagedPointer => ManagedType.IsPointer;
-    public bool RequiresNativePointer => !IsVoid && !IsEnum && !IsPrimitive && !IsBool; 
+    public bool RequiresNativePointer => !IsVoid && !IsEnum && !IsPrimitive && !IsBool;
+
+    public bool IsNullableValueType([NotNullWhen(true)] out Type? valueType)
+    {
+        return ManagedType.IsNullableValueType(out valueType);
+    }
 
     private readonly Dictionary<CodeLanguage, string> m_typeNames;
     private readonly Dictionary<LanguagePair, string> m_typeConversions;
@@ -284,7 +290,11 @@ CodeLanguage targetLanguage
 
                 conversion = $"new {cTypeName}({{0}}).AllocateGCHandleAndGetAddress()";
             } else {
-                conversion = "{0}.AllocateGCHandleAndGetAddress()";
+                if (IsNullableValueType(out Type? valueType)) {
+                    conversion = "{0}.HasValue ? {0}.Value.AllocateGCHandleAndGetAddress() : default";
+                } else {
+                    conversion = "{0}.AllocateGCHandleAndGetAddress()";
+                }
             }
 
             return conversion;

Samples/Beyond.NET.Sample.Managed/Source/StructTest.cs

@@ -17,4 +17,21 @@ public StructTest(string? name)
             return new StructTest("Test");
         }
     }
+    
+    public static void GetNullableStructReturnValueInOutParameter(
+        bool returnNull, 
+        out StructTest? returnValue
+    )
+    {
+        if (returnNull) {
+            returnValue = null;
+        } else {
+            returnValue = new StructTest("Test");
+        }
+    }
+    
+    public static StructTest? GetNullableStructReturnValueOfRefParameter(ref StructTest? returnValue)
+    {
+        return returnValue;
+    }
 }

Samples/Beyond.NET.Sample.Swift/Tests/TestClasses/StructTestTests.swift

@@ -40,4 +40,66 @@ final class StructTestTests: XCTestCase {
 
 		XCTAssertEqual(nameNew, nameNewRet)
 	}
+    
+    func testNullableValueTypes() {
+        do {
+            let nullRetVal = try Beyond_NET_Sample_StructTest.getNullableStructReturnValue(true)
+            
+            XCTAssertNil(nullRetVal)
+        } catch {
+            XCTFail("StructTest.GetNullableStructReturnValue should not throw")
+        }
+        
+        do {
+            let structRetVal = try Beyond_NET_Sample_StructTest.getNullableStructReturnValue(false)
+            
+            XCTAssertNotNil(structRetVal)
+        } catch {
+            XCTFail("StructTest.GetNullableStructReturnValue should not throw")
+        }
+        
+        do {
+            var nullOutRetVal: Beyond_NET_Sample_StructTest?
+            
+            try Beyond_NET_Sample_StructTest.getNullableStructReturnValueInOutParameter(true,
+                                                                                        &nullOutRetVal)
+            
+            XCTAssertNil(nullOutRetVal)
+        } catch {
+            XCTFail("StructTest.GetNullableStructReturnValueInOutParameter should not throw")
+        }
+        
+        do {
+            var structRetVal: Beyond_NET_Sample_StructTest?
+            
+            try Beyond_NET_Sample_StructTest.getNullableStructReturnValueInOutParameter(false,
+                                                                                        &structRetVal)
+            
+            XCTAssertNotNil(structRetVal)
+        } catch {
+            XCTFail("StructTest.GetNullableStructReturnValueInOutParameter should not throw")
+        }
+        
+        do {
+            var nullRef: Beyond_NET_Sample_StructTest?
+            
+            let ret = try Beyond_NET_Sample_StructTest.getNullableStructReturnValueOfRefParameter(&nullRef)
+            
+            XCTAssertNil(ret)
+            XCTAssertTrue(nullRef == ret)
+        } catch {
+            XCTFail("StructTest.GetNullableStructReturnValueOfRefParameter should not throw")
+        }
+        
+        do {
+            var structRef = try Beyond_NET_Sample_StructTest("test".dotNETString())
+            
+            let ret = try Beyond_NET_Sample_StructTest.getNullableStructReturnValueOfRefParameter(&structRef)
+            
+            XCTAssertNotNil(ret)
+            XCTAssertTrue(structRef == ret)
+        } catch {
+            XCTFail("StructTest.GetNullableStructReturnValueOfRefParameter should not throw")
+        }
+    }
 }