Merge pull request #663 from rolfbjarne/special-objc-cxtype

Fix handling ElaboratedType and TypeWithKeyword instances of id/SEL/Class.

Author: tannergooding

sources/ClangSharp/Types/ElaboratedType.cs

@@ -12,7 +12,7 @@ public sealed class ElaboratedType : TypeWithKeyword
     private readonly ValueLazy<Type> _namedType;
     private readonly ValueLazy<TagDecl?> _ownedTagDecl;
 
-    internal ElaboratedType(CXType handle) : base(handle, CXType_Elaborated, CX_TypeClass_Elaborated)
+    internal ElaboratedType(CXType handle) : base(handle, CXType_Elaborated, CX_TypeClass_Elaborated, CXType_ObjCClass, CXType_ObjCId, CXType_ObjCSel)
     {
         _namedType = new ValueLazy<Type>(() => TranslationUnit.GetOrCreate<Type>(Handle.NamedType));
         _ownedTagDecl = new ValueLazy<TagDecl?>(() => !Handle.OwnedTagDecl.IsNull ?TranslationUnit.GetOrCreate<TagDecl>(Handle.OwnedTagDecl) : null);

sources/ClangSharp/Types/Type.cs

@@ -18,9 +18,13 @@ public unsafe class Type : IEquatable<Type>
     private readonly ValueLazy<Type> _pointeeType;
     private readonly ValueLazy<TranslationUnit> _translationUnit;
 
-    protected Type(CXType handle, CXTypeKind expectedKind, CX_TypeClass expectedTypeClass)
+    protected Type(CXType handle, CXTypeKind expectedKind, CX_TypeClass expectedTypeClass, params ReadOnlySpan<CXTypeKind> additionalExpectedKinds)
     {
-        if (handle.kind != expectedKind)
+#if NET10_0_OR_GREATER
+        if (handle.kind != expectedKind && !additionalExpectedKinds.Contains(handle.kind))
+#else
+        if (handle.kind != expectedKind && !Contains(additionalExpectedKinds, handle.kind))
+#endif
         {
             throw new ArgumentOutOfRangeException(nameof(handle));
         }
@@ -39,6 +43,20 @@ protected Type(CXType handle, CXTypeKind expectedKind, CX_TypeClass expectedType
         _translationUnit = new ValueLazy<TranslationUnit>(() => TranslationUnit.GetOrCreate((CXTranslationUnit)Handle.data[1]));
     }
 
+#if !NET10_0_OR_GREATER
+    private static bool Contains(ReadOnlySpan<CXTypeKind> kinds, CXTypeKind find)
+    {
+        for (var i = 0; i < kinds.Length; i++)
+        {
+            if (kinds[i] == find)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+#endif
+
     public CXXRecordDecl? AsCXXRecordDecl => AsTagDecl as CXXRecordDecl;
 
     public string AsString => _asString.Value;

sources/ClangSharp/Types/TypeWithKeyword.cs

@@ -1,12 +1,13 @@
 // Copyright (c) .NET Foundation and Contributors. All Rights Reserved. Licensed under the MIT License (MIT). See License.md in the repository root for more information.
 
+using System;
 using ClangSharp.Interop;
 
 namespace ClangSharp;
 
 public class TypeWithKeyword : Type
 {
-    private protected TypeWithKeyword(CXType handle, CXTypeKind expectedTypeKind, CX_TypeClass expectedTypeClass) : base(handle, expectedTypeKind, expectedTypeClass)
+    private protected TypeWithKeyword(CXType handle, CXTypeKind expectedTypeKind, CX_TypeClass expectedTypeClass, params ReadOnlySpan<CXTypeKind> additionalExpectedKinds) : base(handle, expectedTypeKind, expectedTypeClass, additionalExpectedKinds)
     {
     }
 }

sources/ClangSharp/Types/TypedefType.cs

@@ -11,7 +11,7 @@ public sealed class TypedefType : Type
 {
     private readonly ValueLazy<TypedefNameDecl> _decl;
 
-    internal TypedefType(CXType handle) : base(handle, CXType_Typedef, CX_TypeClass_Typedef)
+    internal TypedefType(CXType handle) : base(handle, CXType_Typedef, CX_TypeClass_Typedef, CXType_ObjCClass, CXType_ObjCId, CXType_ObjCSel)
     {
         _decl = new ValueLazy<TypedefNameDecl>(() => TranslationUnit.GetOrCreate<TypedefNameDecl>(Handle.Declaration));
     }

tests/ClangSharp.UnitTests/ObjectiveCTest.cs

@@ -96,7 +96,48 @@ @interface MyClass
         var pointee2Type = pointeeType.PointeeType;
         Assert.That(pointee2Type.Kind, Is.EqualTo(CXTypeKind.CXType_ObjCInterface), "pointee2Type.Kind");
     }
-    
+
+    [Test]
+    public void BlockTypes()
+    {
+        var inputContents = $$"""
+@interface MyClass
+-(MyClass *(^)(id))instanceMethod1;
+-(MyClass *(^)(SEL))instanceMethod2;
+-(MyClass *(^)(Class))instanceMethod3;
+@end
+""";
+        using var translationUnit = CreateTranslationUnit(inputContents, "objective-c++");
+
+        var classes = translationUnit.TranslationUnitDecl.Decls.OfType<ObjCInterfaceDecl>().ToList();
+
+        var myClass = classes.SingleOrDefault(v => v.Name == "MyClass")!;
+        Assert.That(myClass, Is.Not.Null, "MyClass");
+
+        var info = new[] {
+            (Name: "instanceMethod1", Type: CXTypeKind.CXType_ObjCId),
+            (Name: "instanceMethod2", Type: CXTypeKind.CXType_ObjCSel),
+            (Name: "instanceMethod3", Type: CXTypeKind.CXType_ObjCClass),
+        };
+
+        foreach (var i in info)
+        {
+            var instanceMethod = myClass.Methods.SingleOrDefault(v => v.Name == i.Name)!;
+            Assert.That(instanceMethod, Is.Not.Null, "instanceMethod");
+            var returnType = instanceMethod.ReturnType;
+            Assert.That(returnType.Kind, Is.EqualTo(CXTypeKind.CXType_BlockPointer), "returnType.Kind");
+            var pointeeType = returnType.PointeeType;
+            Assert.That(pointeeType.Kind, Is.EqualTo(CXTypeKind.CXType_FunctionProto), "pointeeType.Kind");
+            var functionProtoType = (FunctionProtoType)pointeeType;
+            Assert.That(functionProtoType.ParamTypes.Count, Is.EqualTo(1), "functionProtoType.ParamTypes.Count()");
+            var paramType = functionProtoType.ParamTypes[0];
+            Assert.That(paramType.Kind, Is.EqualTo(i.Type), "paramType.Kind");
+            var elaboratedParamType = (ElaboratedType)paramType;
+            Assert.That(elaboratedParamType, Is.Not.Null, "elaboratedParamType");
+            Assert.That(elaboratedParamType.Desugar, Is.Not.Null, "elaboratedParamType.Desugar");
+        }
+    }
+
     private static void AssertNeedNewClangSharp()
     {
         var forceRun = !string.IsNullOrEmpty(Environment.GetEnvironmentVariable("FORCE_RUN"));