Expose AvailabilityAttr in its various forms to ClangSharp.

sources/ClangSharp.Interop/Extensions/CXCursor.cs

@@ -513,6 +513,51 @@ public readonly string AttrKindSpelling
 
     public readonly CXAvailabilityKind Availability => clang.getCursorAvailability(this);
 
+    public readonly VersionTuple? AvailabilityAttributeDeprecated
+    {
+        get
+        {
+            VersionTuple rv = default;
+            if (clangsharp.Cursor_getAvailabilityAttributeDeprecated(this, &rv) == 1)
+            {
+                return rv;
+            }
+            return null;
+        }
+    }
+
+    public readonly VersionTuple? AvailabilityAttributeIntroduced
+    {
+        get
+        {
+            VersionTuple rv = default;
+            if (clangsharp.Cursor_getAvailabilityAttributeIntroduced(this, &rv) == 1)
+            {
+                return rv;
+            }
+            return null;
+        }
+    }
+
+    public readonly CXString AvailabilityAttributeMessage => clangsharp.Cursor_getAvailabilityAttributeMessage(this);
+
+    public readonly VersionTuple? AvailabilityAttributeObsoleted
+    {
+        get
+        {
+            VersionTuple rv = default;
+            if (clangsharp.Cursor_getAvailabilityAttributeObsoleted(this, &rv) == 1)
+            {
+                return rv;
+            }
+            return null;
+        }
+    }
+
+    public readonly CXString AvailabilityAttributePlatformIdentifierName => clangsharp.Cursor_getAvailabilityAttributePlatformIdentifierName(this);
+
+    public bool AvailabilityAttributeUnavailable => clangsharp.Cursor_getAvailabilityAttributeUnavailable(this) != 0;
+
     public readonly CXBinaryOperatorKind BinaryOperatorKind => clangsharp.Cursor_getBinaryOpcode(this);
 
     public readonly CXString BinaryOperatorKindSpelling

sources/ClangSharp.Interop/clang/VersionTuple.cs

@@ -0,0 +1,204 @@
+// 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.
+
+// Ported from https://github.com/llvm/llvm-project/tree/llvmorg-21.1.8/clang/include/clang-c
+// Original source is Copyright (c) the LLVM Project and Contributors. Licensed under the Apache License v2.0 with LLVM Exceptions. See NOTICE.txt in the project root for license information.
+
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace ClangSharp.Interop;
+
+[StructLayout(LayoutKind.Sequential)]
+public struct VersionTuple : IEquatable<VersionTuple>
+{
+    public static readonly VersionTuple Empty;
+
+    private readonly uint major;
+    private readonly uint minor;
+    private readonly uint subminor;
+    private readonly uint build;
+
+    private const uint HasFlag = 0x80000000u; // 1 << 31;
+    private const uint ValueMask = uint.MaxValue & ~HasFlag;
+
+    public VersionTuple(uint major, uint minor, uint subminor, uint build)
+    {
+        this.major = major;
+        this.minor = minor | HasFlag;
+        this.subminor = subminor | HasFlag;
+        this.build = build | HasFlag;
+    }
+
+    public VersionTuple(uint major, uint minor, uint subminor)
+    {
+        this.major = major;
+        this.minor = minor | HasFlag;
+        this.subminor = subminor | HasFlag;
+        build = 0;
+    }
+
+    public VersionTuple(uint major, uint minor)
+    {
+        this.major = major;
+        this.minor = minor | HasFlag;
+        subminor = 0;
+        build = 0;
+    }
+
+    public VersionTuple(uint major)
+    {
+        this.major = major;
+        minor = 0;
+        subminor = 0;
+        build = 0;
+    }
+
+    public uint Major => major;
+
+    public uint? Minor
+    {
+        get
+        {
+            if (HasMinor)
+            {
+                return minor & ValueMask;
+            }
+            return null;
+        }
+    }
+
+    public uint? Subminor
+    {
+        get
+        {
+            if (HasSubminor)
+            {
+                return subminor & ValueMask;
+            }
+            return null;
+        }
+    }
+
+    public uint? Build
+    {
+        get
+        {
+            if (HasBuild)
+            {
+                return build & ValueMask;
+            }
+            return null;
+        }
+    }
+
+    private uint MinorOrZero => Minor ?? 0;
+    private uint SubminorOrZero => Subminor ?? 0;
+    private uint BuildOrZero => Build ?? 0;
+
+    public bool HasMinor => (minor & HasFlag) == HasFlag;
+    public bool HasSubminor => (subminor & HasFlag) == HasFlag;
+    public bool HasBuild => (build & HasFlag) == HasFlag;
+
+    public bool IsEmpty => major == 0 && minor == 0 && subminor == 0 && build == 0;
+
+    public static bool operator ==(VersionTuple x, VersionTuple y)
+    {
+        return x.Major == y.Major &&
+            x.MinorOrZero == y.MinorOrZero &&
+            x.SubminorOrZero == y.SubminorOrZero &&
+            x.BuildOrZero == y.BuildOrZero;
+    }
+
+    public static bool operator !=(VersionTuple x, VersionTuple y)
+        => !(x == y);
+
+    public static bool operator <(VersionTuple x, VersionTuple y)
+    {
+        if (x.Major != y.Major)
+        {
+            return x.Major < y.Major;
+        }
+        if (x.MinorOrZero != y.MinorOrZero)
+        {
+            return x.MinorOrZero < y.MinorOrZero;
+        }
+        if (x.SubminorOrZero != y.SubminorOrZero)
+        {
+            return x.MinorOrZero < y.MinorOrZero;
+        }
+        if (x.BuildOrZero != y.BuildOrZero)
+        {
+            return x.BuildOrZero < y.BuildOrZero;
+        }
+        return false;
+    }
+
+    public static bool operator >(VersionTuple x, VersionTuple y)
+    {
+        if (x.Major != y.Major)
+        {
+            return x.Major > y.Major;
+        }
+        if (x.MinorOrZero != y.MinorOrZero)
+        {
+            return x.MinorOrZero > y.MinorOrZero;
+        }
+        if (x.SubminorOrZero != y.SubminorOrZero)
+        {
+            return x.MinorOrZero > y.MinorOrZero;
+        }
+        if (x.BuildOrZero != y.BuildOrZero)
+        {
+            return x.BuildOrZero > y.BuildOrZero;
+        }
+        return false;
+    }
+
+    public static bool operator <=(VersionTuple x, VersionTuple y)
+        => x == y || x < y;
+
+    public static bool operator >=(VersionTuple x, VersionTuple y)
+        => x == y || x > y;
+
+    public override bool Equals(object? obj)
+    {
+        if (obj is VersionTuple vt)
+        {
+            return vt == this;
+        }
+        return false;
+    }
+
+    bool IEquatable<VersionTuple>.Equals(VersionTuple version)
+    {
+        return this == version;
+    }
+
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(major, minor, subminor, build);
+    }
+
+    public override string ToString()
+    {
+        var sb = new StringBuilder();
+        _ = sb.Append(Major);
+        if (HasMinor)
+        {
+            _ = sb.Append('.');
+            _ = sb.Append(Minor);
+            if (HasSubminor)
+            {
+                _ = sb.Append('.');
+                _ = sb.Append(Subminor);
+                if (HasBuild)
+                {
+                    _ = sb.Append('.');
+                    _ = sb.Append(Build);
+                }
+            }
+        }
+        return sb.ToString();
+    }
+}

sources/ClangSharp.Interop/clangsharp/clangsharp.cs

@@ -6,7 +6,7 @@
 
 namespace ClangSharp.Interop;
 
-public static partial class @clangsharp
+public static unsafe partial class @clangsharp
 {
     [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getArgument", ExactSpelling = true)]
     public static extern CXCursor Cursor_getArgument(CXCursor C, [NativeTypeName("unsigned int")] uint i);
@@ -33,6 +33,28 @@ public static partial class @clangsharp
     [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAttrKind", ExactSpelling = true)]
     public static extern CX_AttrKind Cursor_getAttrKind(CXCursor C);
 
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAvailabilityAttributeDeprecated", ExactSpelling = true)]
+    [return: NativeTypeName("unsigned int")]
+    public static extern uint Cursor_getAvailabilityAttributeDeprecated(CXCursor param0, [NativeTypeName("llvm::VersionTuple *")] VersionTuple* version);
+
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAvailabilityAttributeIntroduced", ExactSpelling = true)]
+    [return: NativeTypeName("unsigned int")]
+    public static extern uint Cursor_getAvailabilityAttributeIntroduced(CXCursor param0, [NativeTypeName("llvm::VersionTuple *")] VersionTuple* version);
+
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAvailabilityAttributeMessage", ExactSpelling = true)]
+    public static extern CXString Cursor_getAvailabilityAttributeMessage(CXCursor C);
+
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAvailabilityAttributeObsoleted", ExactSpelling = true)]
+    [return: NativeTypeName("unsigned int")]
+    public static extern uint Cursor_getAvailabilityAttributeObsoleted(CXCursor param0, [NativeTypeName("llvm::VersionTuple *")] VersionTuple* version);
+
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAvailabilityAttributePlatformIdentifierName", ExactSpelling = true)]
+    public static extern CXString Cursor_getAvailabilityAttributePlatformIdentifierName(CXCursor C);
+
+    [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getAvailabilityAttributeUnavailable", ExactSpelling = true)]
+    [return: NativeTypeName("unsigned int")]
+    public static extern uint Cursor_getAvailabilityAttributeUnavailable(CXCursor param0);
+
     [DllImport("libClangSharp", CallingConvention = CallingConvention.Cdecl, EntryPoint = "clangsharp_Cursor_getBase", ExactSpelling = true)]
     public static extern CXCursor Cursor_getBase(CXCursor C, [NativeTypeName("unsigned int")] uint i);
 

sources/ClangSharp/Cursors/Attrs/Attr.cs

@@ -464,6 +464,18 @@ private protected Attr(CXCursor handle) : base(handle, handle.Kind)
         _ => new Attr(handle),
     };
 
+    public VersionTuple? AvailabilityAttributeDeprecated => Handle.AvailabilityAttributeDeprecated;
+
+    public VersionTuple? AvailabilityAttributeIntroduced => Handle.AvailabilityAttributeIntroduced;
+
+    public string AvailabilityAttributeMessage => Handle.AvailabilityAttributeMessage.ToString();
+
+    public VersionTuple? AvailabilityAttributeObsoleted => Handle.AvailabilityAttributeObsoleted;
+
+    public string AvailabilityAttributePlatformIdentifierName => Handle.AvailabilityAttributePlatformIdentifierName.ToString();
+
+    public bool AvailabilityAttributeUnavailable => Handle.AvailabilityAttributeUnavailable;
+
     public bool IsImplicit => Handle.IsImplicit;
 
     public bool IsPackExpansion => Handle.IsPackExpansion;