Primitive type resolution

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

@@ -0,0 +1,45 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Silk.NET.SilkTouch.Symbols;
+
+namespace Silk.NET.SilkTouch.TypeResolution;
+
+/// <summary>
+/// A simple type resolver to resolve <see cref="UnresolvedTypeReference"/>s that refer to primitive types.
+/// </summary>
+public sealed class PrimitiveTypeResolver : SimpleTypeResolverBase
+{
+
+    /// <inheritdoc />
+    public PrimitiveTypeResolver(TypeStore typeStore) : base(typeStore)
+    {
+    }
+
+    private static ExternalTypeReference CreateExternalTypeRef(string @namespace, string name)
+        => new ExternalTypeReference(new IdentifierSymbol(@namespace), new IdentifierSymbol(name));
+    private static readonly Dictionary<string, TypeReference> _typeMap = new Dictionary<string, TypeReference>()
+    {
+        ["bool"] = CreateExternalTypeRef("System", "Boolean"),
+        ["byte"] = CreateExternalTypeRef("System", "Byte"),
+        ["sbyte"] = CreateExternalTypeRef("System", "SByte"),
+        ["char"] = CreateExternalTypeRef("System", "Char"),
+        ["decimal"] = CreateExternalTypeRef("System", "Decimal"),
+        ["double"] = CreateExternalTypeRef("System", "Double"),
+        ["float"] = CreateExternalTypeRef("System", "Single"),
+        ["int"] = CreateExternalTypeRef("System", "Int32"),
+        ["uint"] = CreateExternalTypeRef("System", "UInt32"),
+        ["nint"] = CreateExternalTypeRef("System", "IntPtr"),
+        ["nuint"] = CreateExternalTypeRef("System", "UIntPtr"),
+        ["long"] = CreateExternalTypeRef("System", "Int64"),
+        ["ulong"] = CreateExternalTypeRef("System", "UInt64"),
+        ["short"] = CreateExternalTypeRef("System", "Int16"),
+        ["ushort"] = CreateExternalTypeRef("System", "UInt16"),
+    };
+
+    /// <inheritdoc />
+    protected override bool TryResolve(UnresolvedTypeReference utr, out TypeReference? resolved)
+    {
+        return _typeMap.TryGetValue(utr.Text, out resolved);
+    }
+}

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

@@ -6,7 +6,7 @@ namespace LIBRARY_NAMESPACE
 {
     public struct Test
     {
-        public int f1;
-        public int f2;
+        public System.Int32 f1;
+        public System.Int32 f2;
     }
-}
+}

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

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

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

@@ -55,6 +55,7 @@ public static string GetCSharpOutputFromCpp(string cpp)
         var processors = new SymbolVisitor[]
         {
             ActivatorUtilities.CreateInstance<PointerTypeResolver>(serviceProvider, typeStore),
+            ActivatorUtilities.CreateInstance<PrimitiveTypeResolver>(serviceProvider, typeStore),
 
             typeScopeSymbolVisitor,
             ActivatorUtilities.CreateInstance<NameResolverSymbolVisitor>

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

@@ -0,0 +1,55 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using Silk.NET.SilkTouch.Symbols;
+using Xunit;
+
+namespace Silk.NET.SilkTouch.TypeResolution.Tests;
+
+public sealed class PrimitiveTypeResolverTests
+{
+    [Theory, Trait("Category", "Type Resolution"),
+        InlineData("bool", "System", "Boolean"),
+        InlineData("byte", "System", "Byte"),
+        InlineData("sbyte", "System", "SByte"),
+        InlineData("char", "System", "Char"),
+        InlineData("decimal", "System", "Decimal"),
+        InlineData("double", "System", "Double"),
+        InlineData("float", "System", "Single"),
+        InlineData("int", "System", "Int32"),
+        InlineData("uint", "System", "UInt32"),
+        InlineData("nint", "System", "IntPtr"),
+        InlineData("nuint", "System", "UIntPtr"),
+        InlineData("long", "System", "Int64"),
+        InlineData("ulong", "System", "UInt64"),
+        InlineData("short", "System", "Int16"),
+        InlineData("ushort", "System", "UInt16"),
+    ]
+    public void ShouldResolve(string text, string @namespace, string identifier)
+    {
+        var symbol = new UnresolvedTypeReference(text);
+        var output = new PrimitiveTypeResolver(new TypeStore());
+
+        var finalSymbol = output.Visit(symbol);
+        var @ref = Assert.IsType<ExternalTypeReference>(finalSymbol);
+        Assert.Equal(@namespace, @ref.Namespace?.Value);
+        Assert.Equal(identifier, @ref.TypeIdentifier.Value);
+    }
+
+    [Theory, Trait("Category", "Type Resolution"),
+        InlineData(""),
+        InlineData("a"),
+        InlineData("*"),
+        InlineData("a.b.c"),
+        InlineData("longType"),
+        InlineData("using")
+    ]
+    public void ShouldNotResolve(string text)
+    {
+        var symbol = new UnresolvedTypeReference(text);
+        var output = new PrimitiveTypeResolver(new TypeStore());
+
+        var finalSymbol = output.Visit(symbol);
+        Assert.IsNotType<ExternalTypeReference>(finalSymbol);
+    }
+}