Merge pull request #389 from tannergooding/main

tannergooding · web-flow · commit ec8c7a5b5ed6 · 2022-09-18T10:57:50.000-07:00
Adding support for decltype
diff --git a/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs b/sources/ClangSharp.PInvokeGenerator/PInvokeGenerator.cs
@@ -2092,6 +2092,10 @@ private CallingConvention GetCallingConvention(Cursor? cursor, Cursor? context,
                 }
             }
         }
+        else if (type is DecltypeType decltypeType)
+        {
+            return GetCallingConvention(cursor, context, decltypeType.UnderlyingType, ref wasRemapped);
+        }
         else if (type is FunctionType functionType)
         {
             var callingConv = functionType.CallConv;
@@ -3021,6 +3025,10 @@ private string GetTypeName(Cursor? cursor, Cursor? context, Type rootType, Type
                     }
                 }
             }
+            else if (type is DecltypeType decltypeType)
+            {
+                result.typeName = GetTypeName(cursor, context, rootType, decltypeType.UnderlyingType, ignoreTransparentStructsWhereRequired, out _);
+            }
             else if (type is DeducedType deducedType)
             {
                 result.typeName = GetTypeName(cursor, context, rootType, deducedType.CanonicalType, ignoreTransparentStructsWhereRequired, out _);
@@ -3536,6 +3544,10 @@ private void GetTypeSize(Cursor cursor, Type type, ref long alignment32, ref lon
                 }
             }
         }
+        else if (type is DecltypeType decltypeType)
+        {
+            GetTypeSize(cursor, decltypeType.UnderlyingType, ref alignment32, ref alignment64, ref has8BytePrimitiveField, out size32, out size64);
+        }
         else if (type is ElaboratedType elaboratedType)
         {
             GetTypeSize(cursor, elaboratedType.NamedType, ref alignment32, ref alignment64, ref has8BytePrimitiveField, out size32, out size64);
@@ -4465,6 +4477,10 @@ private bool IsFixedSize(Cursor cursor, Type type)
         {
             return true;
         }
+        else if (type is DecltypeType decltypeType)
+        {
+            return IsFixedSize(cursor, decltypeType.UnderlyingType);
+        }
         else if (type is ElaboratedType elaboratedType)
         {
             return IsFixedSize(cursor, elaboratedType.NamedType);
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/Base/StructDeclarationTest.cs
@@ -37,6 +37,9 @@ public abstract class StructDeclarationTest : PInvokeGeneratorTest
     [Test]
     public Task BitfieldTest() => BitfieldTestImpl();
 
+    [Test]
+    public Task DeclTypeTest() => DeclTypeTestImpl();
+
     [Test]
     public Task ExcludeTest() => ExcludeTestImpl();
 
@@ -216,6 +219,8 @@ public abstract class StructDeclarationTest : PInvokeGeneratorTest
 
     protected abstract Task BitfieldTestImpl();
 
+    protected abstract Task DeclTypeTestImpl();
+
     protected abstract Task ExcludeTestImpl();
 
     protected abstract Task FixedSizedBufferNonPrimitiveTestImpl(string nativeType, string expectedManagedType);
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleUnix/StructDeclarationTest.cs
@@ -320,6 +320,37 @@ public uint o0_b1_1
         return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"using System;
+using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        [NativeTypeName(""decltype(&MyFunction)"")]
+        public IntPtr _callback;
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+        return ValidateGeneratedCSharpCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleWindows/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpCompatibleWindows/StructDeclarationTest.cs
@@ -324,6 +324,37 @@ public uint o0_b1_1
         return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"using System;
+using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public partial struct MyStruct
+    {
+        [NativeTypeName(""decltype(&MyFunction)"")]
+        public IntPtr _callback;
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+        return ValidateGeneratedCSharpCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestUnix/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestUnix/StructDeclarationTest.cs
@@ -320,6 +320,36 @@ public uint o0_b1_1
         return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public unsafe partial struct MyStruct
+    {
+        [NativeTypeName(""decltype(&MyFunction)"")]
+        public delegate* unmanaged[Cdecl]<void> _callback;
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+        return ValidateGeneratedCSharpLatestUnixBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestWindows/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpLatestWindows/StructDeclarationTest.cs
@@ -324,6 +324,36 @@ public uint o0_b1_1
         return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public unsafe partial struct MyStruct
+    {
+        [NativeTypeName(""decltype(&MyFunction)"")]
+        public delegate* unmanaged[Cdecl]<void> _callback;
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+        return ValidateGeneratedCSharpLatestWindowsBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewUnix/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewUnix/StructDeclarationTest.cs
@@ -320,6 +320,36 @@ public uint o0_b1_1
         return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public unsafe partial struct MyStruct
+    {
+        [NativeTypeName(""decltype(&MyFunction)"")]
+        public delegate* unmanaged[Cdecl]<void> _callback;
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+        return ValidateGeneratedCSharpPreviewUnixBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewWindows/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/CSharpPreviewWindows/StructDeclarationTest.cs
@@ -324,6 +324,36 @@ public uint o0_b1_1
         return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"using System.Runtime.InteropServices;
+
+namespace ClangSharp.Test
+{
+    public unsafe partial struct MyStruct
+    {
+        [NativeTypeName(""decltype(&MyFunction)"")]
+        public delegate* unmanaged[Cdecl]<void> _callback;
+    }
+
+    public static partial class Methods
+    {
+        [DllImport(""ClangSharpPInvokeGenerator"", CallingConvention = CallingConvention.Cdecl, ExactSpelling = true)]
+        public static extern void MyFunction();
+    }
+}
+";
+        return ValidateGeneratedCSharpPreviewWindowsBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleUnix/StructDeclarationTest.cs
@@ -296,6 +296,35 @@ struct MyStruct3
         return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""_callback"" access=""public"">
+        <type native=""decltype(&amp;MyFunction)"">IntPtr</type>
+      </field>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
+        <type>void</type>
+      </function>
+    </class>
+  </namespace>
+</bindings>
+";
+        return ValidateGeneratedXmlCompatibleUnixBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleWindows/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlCompatibleWindows/StructDeclarationTest.cs
@@ -302,6 +302,35 @@ struct MyStruct3
         return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"">
+      <field name=""_callback"" access=""public"">
+        <type native=""decltype(&amp;MyFunction)"">IntPtr</type>
+      </field>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
+        <type>void</type>
+      </function>
+    </class>
+  </namespace>
+</bindings>
+";
+        return ValidateGeneratedXmlCompatibleWindowsBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestUnix/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestUnix/StructDeclarationTest.cs
@@ -296,6 +296,35 @@ struct MyStruct3
         return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
     }
 
+    protected override Task DeclTypeTestImpl()
+    {
+        var inputContents = @"extern ""C"" void MyFunction();
+
+typedef struct
+{
+    decltype(&MyFunction) _callback;
+} MyStruct;
+";
+
+        var expectedOutputContents = @"<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes"" ?>
+<bindings>
+  <namespace name=""ClangSharp.Test"">
+    <struct name=""MyStruct"" access=""public"" unsafe=""true"">
+      <field name=""_callback"" access=""public"">
+        <type native=""decltype(&amp;MyFunction)"">delegate* unmanaged[Cdecl]&lt;void&gt;</type>
+      </field>
+    </struct>
+    <class name=""Methods"" access=""public"" static=""true"">
+      <function name=""MyFunction"" access=""public"" lib=""ClangSharpPInvokeGenerator"" convention=""Cdecl"" static=""true"">
+        <type>void</type>
+      </function>
+    </class>
+  </namespace>
+</bindings>
+";
+        return ValidateGeneratedXmlLatestUnixBindingsAsync(inputContents, expectedOutputContents);
+    }
+
     protected override Task ExcludeTestImpl()
     {
         var inputContents = "typedef struct MyStruct MyStruct;";
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestWindows/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlLatestWindows/StructDeclarationTest.cs
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewUnix/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewUnix/StructDeclarationTest.cs
diff --git a/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewWindows/StructDeclarationTest.cs b/tests/ClangSharp.PInvokeGenerator.UnitTests/XmlPreviewWindows/StructDeclarationTest.cs

Original file line number	Diff line number	Diff line change
`@@ -2092,6 +2092,10 @@ private CallingConvention GetCallingConvention(Cursor? cursor, Cursor? context,`
`2092`	`2092`	`}`
`2093`	`2093`	`}`
`2094`	`2094`	`}`
	`2095`	`+ else if (type is DecltypeType decltypeType)`
	`2096`	`+ {`
	`2097`	`+ return GetCallingConvention(cursor, context, decltypeType.UnderlyingType, ref wasRemapped);`
	`2098`	`+ }`
`2095`	`2099`	`else if (type is FunctionType functionType)`
`2096`	`2100`	`{`
`2097`	`2101`	`var callingConv = functionType.CallConv;`
`@@ -3021,6 +3025,10 @@ private string GetTypeName(Cursor? cursor, Cursor? context, Type rootType, Type`
`3021`	`3025`	`}`
`3022`	`3026`	`}`
`3023`	`3027`	`}`
	`3028`	`+ else if (type is DecltypeType decltypeType)`
	`3029`	`+ {`
	`3030`	`+ result.typeName = GetTypeName(cursor, context, rootType, decltypeType.UnderlyingType, ignoreTransparentStructsWhereRequired, out _);`
	`3031`	`+ }`
`3024`	`3032`	`else if (type is DeducedType deducedType)`
`3025`	`3033`	`{`
`3026`	`3034`	`result.typeName = GetTypeName(cursor, context, rootType, deducedType.CanonicalType, ignoreTransparentStructsWhereRequired, out _);`
`@@ -3536,6 +3544,10 @@ private void GetTypeSize(Cursor cursor, Type type, ref long alignment32, ref lon`
`3536`	`3544`	`}`
`3537`	`3545`	`}`
`3538`	`3546`	`}`
	`3547`	`+ else if (type is DecltypeType decltypeType)`
	`3548`	`+ {`
	`3549`	`+ GetTypeSize(cursor, decltypeType.UnderlyingType, ref alignment32, ref alignment64, ref has8BytePrimitiveField, out size32, out size64);`
	`3550`	`+ }`
`3539`	`3551`	`else if (type is ElaboratedType elaboratedType)`
`3540`	`3552`	`{`
`3541`	`3553`	`GetTypeSize(cursor, elaboratedType.NamedType, ref alignment32, ref alignment64, ref has8BytePrimitiveField, out size32, out size64);`
`@@ -4465,6 +4477,10 @@ private bool IsFixedSize(Cursor cursor, Type type)`
`4465`	`4477`	`{`
`4466`	`4478`	`return true;`
`4467`	`4479`	`}`
	`4480`	`+ else if (type is DecltypeType decltypeType)`
	`4481`	`+ {`
	`4482`	`+ return IsFixedSize(cursor, decltypeType.UnderlyingType);`
	`4483`	`+ }`
`4468`	`4484`	`else if (type is ElaboratedType elaboratedType)`
`4469`	`4485`	`{`
`4470`	`4486`	`return IsFixedSize(cursor, elaboratedType.NamedType);`