Add ObjCMethodDecl.Selector.

sources/ClangSharp.Interop/Extensions/CXCursor.cs

@@ -1321,6 +1321,8 @@ public readonly ReadOnlySpan<CXCursor> OverriddenCursors
 
     public readonly CXCursor RhsExpr => clangsharp.Cursor_getRhsExpr(this);
 
+    public readonly CXString Selector => clangsharp.Cursor_getSelector(this);
+
     public readonly CXCursor SemanticParent => clang.getCursorSemanticParent(this);
 
     public readonly bool ShouldCopy => clangsharp.Cursor_getShouldCopy(this) != 0;

sources/ClangSharp.Interop/clangsharp/clangsharp.cs

@@ -787,6 +787,9 @@ public static partial class @clangsharp
     [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getRhsExpr", ExactSpelling = true)]
     public static extern CXCursor Cursor_getRhsExpr(CXCursor C);
 
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getSelector", ExactSpelling = true)]
+    public static extern CXString Cursor_getSelector(CXCursor C);
+
     [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getShouldCopy", ExactSpelling = true)]
     [return: NativeTypeName("unsigned int")]
     public static extern uint Cursor_getShouldCopy(CXCursor C);

sources/ClangSharp/Cursors/Decls/ObjCMethodDecl.cs

@@ -55,4 +55,6 @@ internal ObjCMethodDecl(CXCursor handle) : base(handle, handle.Kind, CX_DeclKind
     public Type SendResultType => _sendResultType.Value;
 
     public bool IsPropertyAccessor => Handle.IsPropertyAccessor;
+
+    public string Selector => Handle.Selector.ToString();
 }

sources/libClangSharp/ClangSharp.cpp

@@ -710,6 +710,19 @@ CX_CharacterKind clangsharp_Cursor_getCharacterLiteralKind(CXCursor C) {
     return CX_CLK_Invalid;
 }
 
+CXString clangsharp_Cursor_getSelector(CXCursor C) {
+    if (isDeclOrTU(C.kind)) {
+        const Decl* D = getCursorDecl(C);
+
+        if (const ObjCMethodDecl* OCMD = dyn_cast<ObjCMethodDecl>(D)) {
+            Selector selector = OCMD->getSelector();
+            return createDup(selector.getAsString());
+        }
+    }
+
+    return createEmpty();
+}
+
 CX_StringKind clangsharp_Cursor_getStringLiteralKind(CXCursor C) {
     if (isStmtOrExpr(C.kind)) {
         const Stmt* S = getCursorStmt(C);

sources/libClangSharp/ClangSharp.h

@@ -683,6 +683,8 @@ CLANGSHARP_LINKAGE CXType clangsharp_Cursor_getReturnType(CXCursor C);
 
 CLANGSHARP_LINKAGE CXCursor clangsharp_Cursor_getRhsExpr(CXCursor C);
 
+CLANGSHARP_LINKAGE CXString clangsharp_Cursor_getSelector(CXCursor C);
+
 CLANGSHARP_LINKAGE unsigned clangsharp_Cursor_getShouldCopy(CXCursor C);
 
 CLANGSHARP_LINKAGE CXSourceRange clangsharp_Cursor_getSourceRange(CXCursor C);

tests/ClangSharp.UnitTests/ObjectiveCTest.cs

@@ -10,6 +10,43 @@ namespace ClangSharp.UnitTests;
 [Platform("macosx")]
 public sealed class ObjectiveCTest : TranslationUnitTest
 {
+    [Test]
+    public void Method_Selector()
+    {
+        AssertNeedNewClangSharp();
+
+        var inputContents = $@"
+@interface MyClass
+    @property int P1;
+    -(void) instanceMethod;
+    +(void) staticMethod;
+@end
+";
+
+        using var translationUnit = CreateTranslationUnit(inputContents, "objective-c++");
+
+        var classes = translationUnit.TranslationUnitDecl.Decls.OfType<ObjCInterfaceDecl>().ToList();
+        Assert.That(classes.Count, Is.GreaterThanOrEqualTo(1), $"At least one class");
+        var myClass = classes.SingleOrDefault(v => v.Name == "MyClass")!;
+        Assert.That(myClass, Is.Not.Null, "MyClass");
+
+        var methodP1 = myClass.Methods.SingleOrDefault(v => v.Name == "P1")!;
+        Assert.That(methodP1, Is.Not.Null, "methodP1");
+        Assert.That(methodP1.Selector, Is.EqualTo("P1"), "methodP1.Selector");
+
+        var methodSetP1 = myClass.Methods.SingleOrDefault(v => v.Name == "setP1:")!;
+        Assert.That(methodSetP1, Is.Not.Null, "methodSetP1");
+        Assert.That(methodSetP1.Selector, Is.EqualTo("setP1:"), "methodSetP1.Selector");
+
+        var methodInstanceMethod = myClass.Methods.SingleOrDefault(v => v.Name == "instanceMethod")!;
+        Assert.That(methodInstanceMethod, Is.Not.Null, "methodInstanceMethod");
+        Assert.That(methodInstanceMethod.Selector, Is.EqualTo("instanceMethod"), "methodInstanceMethod.Selector");
+
+        var methodStaticMethod = myClass.Methods.SingleOrDefault(v => v.Name == "staticMethod")!;
+        Assert.That(methodStaticMethod, Is.Not.Null, "methodStaticMethod");
+        Assert.That(methodStaticMethod.Selector, Is.EqualTo("staticMethod"), "methodStaticMethod.Selector");
+    }
+
     [Test]
     public void Category_TypeParamList()
     {