Repeatedly call Basic Type Resolvers

src/generators/Silk.NET.SilkTouch.TypeResolution/SimpleTypeResolverBase.cs

@@ -18,11 +18,19 @@ protected SimpleTypeResolverBase(TypeStore typeStore) : base(typeStore)
     /// <inheritdoc />
     protected override TypeReference VisitTypeReference(TypeReference typeSymbol)
     {
-        if (typeSymbol is UnresolvedTypeReference utr)
+        while (true)
         {
-            return TryResolve(utr, out var result) ? result! : utr;
+            if (typeSymbol is UnresolvedTypeReference utr)
+            {
+                if (TryResolve(utr, out var result))
+                {
+                    typeSymbol = result!;
+                    continue;
+                }
+                return utr;
+            }
+            return base.VisitTypeReference(typeSymbol);
         }
-        return base.VisitTypeReference(typeSymbol);
     }
 
     /// <summary>

tests/Silk.NET.SilkTouch.IntegrationTests/StructIntegrationTests.Test11.verified.txt

@@ -0,0 +1,11 @@
+
+
+/* -------------------------- NEW OUTPUT -------------------------- */
+
+namespace LIBRARY_NAMESPACE
+{
+    public struct Test
+    {
+        public System.Int32*** f1;
+    }
+}

tests/Silk.NET.SilkTouch.IntegrationTests/StructIntegrationTests.cs

@@ -200,4 +200,21 @@ public Task Test10()
 ");
         return Verifier.Verify(result);
     }
+
+    [Fact,
+     Trait("Category", "Integration"),
+     Trait("Source Language", "C++"),
+     Trait("Target Language", "C#"),
+     Trait("Feature", "Structs"),
+     Trait("Feature", "Fields")]
+    public Task Test11()
+    {
+        var result = TestHelper.GetCSharpOutputFromCpp(@"
+#include <stdint.h>
+
+typedef struct {
+    int32_t*** f1;
+} Test;");
+        return Verifier.Verify(result);
+    }
 }

tests/Silk.NET.SilkTouch.TypeResolution.Tests/PointerResolverTests.cs

@@ -39,4 +39,17 @@ public void ShouldNotResolve(string text)
         var finalSymbol = output.Visit(symbol);
         Assert.IsNotType<PointerTypeReference>(finalSymbol);
     }
+
+    [Fact, Trait("Category", "Type Resolution")]
+    public void MultiPointer()
+    {
+        var symbol = new UnresolvedTypeReference("int***");
+        var output = new PointerTypeResolver(new TypeStore());
+
+        var finalSymbol = output.Visit(symbol);
+        var outer = Assert.IsType<PointerTypeReference>(finalSymbol);
+        var middle = Assert.IsType<PointerTypeReference>(outer.Underlying);
+        var inner = Assert.IsType<PointerTypeReference>(middle.Underlying);
+        Assert.IsNotType<PointerTypeReference>(inner.Underlying);
+    }
 }