Fixed the generated C# for a fixed array of pointers.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/Generator/Generators/CSharp/CSharpMarshal.cs

@@ -98,12 +98,20 @@ namespace CppSharp.Generators.CSharp
                         else
                         {
                             var arrayType = array.Type.Desugar();
+                            var finalArrayType = arrayType.GetPointee() ?? arrayType;
                             Class @class;
-                            if (arrayType.TryGetClass(out @class) && @class.IsRefType)
+                            if ((finalArrayType.TryGetClass(out @class)) && @class.IsRefType)
-                                supportBefore.WriteLineIndent(
+                            {
-                                    "{0}[i] = {1}.{2}(*(({1}.{3}*)&({4}[i * sizeof({1}.{3})])));",
+                                if (arrayType == finalArrayType)
-                                    value, array.Type, Helpers.CreateInstanceIdentifier,
+                                    supportBefore.WriteLineIndent(
-                                    Helpers.InternalStruct, Context.ReturnVarName);
+                                        "{0}[i] = {1}.{2}(*(({1}.{3}*)&({4}[i * sizeof({1}.{3})])));",
+                                        value, array.Type, Helpers.CreateInstanceIdentifier,
+                                        Helpers.InternalStruct, Context.ReturnVarName);
+                                else
+                                    supportBefore.WriteLineIndent(
+                                        $@"{value}[i] = {finalArrayType}.{Helpers.CreateInstanceIdentifier}(({
+                                            CSharpTypePrinter.IntPtrType}) {Context.ReturnVarName}[i]);");
+                            }
                             else
                             {
                                 if (arrayType.IsPrimitiveType(PrimitiveType.Char) &&
@@ -483,7 +491,6 @@ namespace CppSharp.Generators.CSharp
             if (!VisitType(array, quals))
                 return false;
 
-            var arrayType = array.Type.Desugar();
             switch (array.SizeType)
             {
                 case ArrayType.ArraySize.Constant:
@@ -497,7 +504,9 @@ namespace CppSharp.Generators.CSharp
                         supportBefore.WriteLine("if ({0} != null)", Context.ArgName);
                         supportBefore.WriteStartBraceIndent();
                         Class @class;
-                        if (arrayType.TryGetClass(out @class) && @class.IsRefType)
+                        var arrayType = array.Type.Desugar();
+                        var finalArrayType = arrayType.GetPointee() ?? arrayType;
+                        if (finalArrayType.TryGetClass(out @class) && @class.IsRefType)
                         {
                             supportBefore.WriteLine("if (value.Length != {0})", array.Size);
                             ThrowArgumentOutOfRangeException();
@@ -505,10 +514,15 @@ namespace CppSharp.Generators.CSharp
                         supportBefore.WriteLine("for (int i = 0; i < {0}; i++)", array.Size);
                         if (@class != null && @class.IsRefType)
                         {
-                            supportBefore.WriteLineIndent(
+                            if (finalArrayType == arrayType)
-                                "*({1}.{2}*) &{0}[i * sizeof({1}.{2})] = *({1}.{2}*){3}[i].{4};",
+                                supportBefore.WriteLineIndent(
-                                Context.ReturnVarName, arrayType, Helpers.InternalStruct,
+                                    "*({1}.{2}*) &{0}[i * sizeof({1}.{2})] = *({1}.{2}*){3}[i].{4};",
-                                Context.ArgName, Helpers.InstanceIdentifier);
+                                    Context.ReturnVarName, arrayType, Helpers.InternalStruct,
+                                    Context.ArgName, Helpers.InstanceIdentifier);
+                            else
+                                supportBefore.WriteLineIndent($@"{Context.ReturnVarName}[i] = ({
+                                    (Context.Context.TargetInfo.PointerWidth == 64 ? "long" : "int")}) {
+                                    Context.ArgName}[i].{Helpers.InstanceIdentifier};");
                         }
                         else
                         {

tests/CSharp/CSharp.Tests.cs

@@ -1108,6 +1108,21 @@ public unsafe class CSharpTests : GeneratorTestFixture
         }
     }
 
+    [Test]
+    public void TestHasFixedArrayOfPointers()
+    {
+        using (var hasFixedArrayOfPointers = new HasFixedArrayOfPointers())
+        {
+            var foos = new Foo[] { new Foo() { A = 5 }, new Foo { A = 15 }, new Foo { A = 20 } };
+            hasFixedArrayOfPointers.FixedArrayOfPointers = foos;
+            for (int i = 0; i < hasFixedArrayOfPointers.FixedArrayOfPointers.Length; i++)
+                Assert.That(hasFixedArrayOfPointers.FixedArrayOfPointers[i].A,
+                    Is.EqualTo(foos[i].A));
+            foreach (var foo in foos)
+                foo.Dispose();
+        }
+    }
+
     private class OverrideVirtualTemplate : VirtualTemplate<int>
     {
         public override int Function

tests/CSharp/CSharp.cpp

@@ -1450,3 +1450,11 @@ int TestArrays::virtualTakeArrays(Foo *fixedArrayOfPointersToObjects[], int fixe
 {
     return takeArrays(fixedArrayOfPointersToObjects, fixedArrayOfPrimitives, fixedArrayOfPointersToPrimitives);
 }
+
+HasFixedArrayOfPointers::HasFixedArrayOfPointers()
+{
+}
+
+HasFixedArrayOfPointers::~HasFixedArrayOfPointers()
+{
+}

tests/CSharp/CSharp.h

@@ -1257,3 +1257,10 @@ class TestForwardedClassInAnotherUnit
 {
 };
 
+class DLL_API HasFixedArrayOfPointers
+{
+public:
+    HasFixedArrayOfPointers();
+    ~HasFixedArrayOfPointers();
+    Foo* fixedArrayOfPointers[3];
+};