Unresolved type symbol (#1006)

Author: HurricanKai

src/generators/Silk.NET.SilkTouch.Scraper/XmlVisitor.cs

@@ -114,10 +114,10 @@ private bool TryResolveTypeRef(string text, [NotNullWhen(true)] out TypeReferenc
     // NOTE: This does not visit types as in class/struct, but visits *references* to types. Like from methods or fields.
     private IEnumerable<Symbol> VisitType(XmlElement type)
     {
-        return
-            TryResolveTypeRef(type.InnerText, out var r)
-                ? new[] { r }
-                : Array.Empty<Symbol>();
+        return new[]
+        {
+            new UnresolvedTypeReference(type.InnerText)
+        };
     }
 
     private IEnumerable<Symbol> VisitStruct(XmlElement @struct)

src/generators/Silk.NET.SilkTouch.Symbols/SymbolVisitor.cs

@@ -61,10 +61,14 @@ protected virtual FieldSymbol VisitField(FieldSymbol fieldSymbol)
     /// <remarks>
     /// The order in which the parts of the struct are visited is kept as an implementation detail. Do not rely on this order.
     /// </remarks>
+    /// <remarks>
+    /// By default visiting <see cref="UnresolvedTypeReference"/> will throw. Visitors involved in type resolution should override this method directly.
+    /// </remarks>
     protected virtual TypeReference VisitTypeReference(TypeReference typeReference)
     {
         if (typeReference is ExternalTypeReference etr) return VisitExternalTypeReference(etr);
         if (typeReference is InternalTypeReference itr) return VisitInternalTypeReference(itr);
+        if (typeReference is UnresolvedTypeReference utr) UnresolvedTypeReference.ThrowInvalidSymbol();
         return ThrowUnknownSymbol<TypeReference>(typeReference);
     }
 

src/generators/Silk.NET.SilkTouch.Symbols/UnresolvedTypeReference.cs

@@ -0,0 +1,22 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Silk.NET.SilkTouch.Symbols;
+
+/// <summary>
+/// Represents an unresolved <see cref="TypeReference"/>. The Text is arbitrary data that should be interpreted into another <see cref="TypeReference"/>.
+/// Visitors are free to throw <see cref="InvalidOperationException"/> using <see cref="ThrowInvalidSymbol"/> when they encounter this symbol, but type resolution should've already happened.
+/// </summary>
+/// <param name="Text">Arbitrary text to interpret</param>
+public sealed record UnresolvedTypeReference(string Text) : TypeReference
+{
+    /// <summary>
+    /// Throw helper to use when encountering <see cref="UnresolvedTypeReference"/> when type resolution should've already happened.
+    /// </summary>
+    /// <exception cref="InvalidOperationException"></exception>
+    public static void ThrowInvalidSymbol()
+    {
+        throw new InvalidOperationException
+            ($"Visited {nameof(UnresolvedTypeReference)}, but type resolution should have already happened.");
+    }
+}

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

@@ -10,7 +10,7 @@ namespace Silk.NET.SilkTouch.IntegrationTests;
 [UsesVerify]
 public class StructIntegrationTests
 {
-    [Fact,
+    [Fact(Skip = "TODO: Reenable after proper type support"),
      Trait("Category", "Integration"),
      Trait("Source Language", "C++"),
      Trait("Target Language", "C#"),

tests/Silk.NET.SilkTouch.Scraper.Tests/FieldScrapingTests.cs

@@ -50,8 +50,7 @@ public void CorrectType()
 
         var symbol = Assert.Single(symbols);
         var field = Assert.IsType<FieldSymbol>(symbol);
-        var type = Assert.IsType<ExternalTypeReference>(field.Type);
-        Assert.Equal("int", type.TypeIdentifier.Value);
-        Assert.Null(type.Namespace);
+        var type = Assert.IsType<UnresolvedTypeReference>(field.Type);
+        Assert.Equal("int", type.Text);
     }
 }

tests/Silk.NET.SilkTouch.Symbols.Tests/SymbolVisitorTests/UnresolvedTypeReferenceTests.cs

@@ -0,0 +1,24 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using Moq;
+using Moq.Protected;
+using Xunit;
+
+namespace Silk.NET.SilkTouch.Symbols.Tests.SymbolVisitorTests;
+
+public class UnresolvedTypeReferenceTests
+{
+    [Fact, Trait("Category", "Symbols")]
+    public void VisitingUnresolvedRefThrows()
+    {
+        var symbol = new UnresolvedTypeReference("");
+        var visitor = new Mock<SymbolVisitor>
+        {
+            CallBase = true
+        };
+
+        Assert.Throws<InvalidOperationException>(() => visitor.Object.Visit(symbol));
+    }
+}