Returned HasFlagCustom back and made it obsolete

src/Avalonia.Base/EnumExtensions.cs

@@ -9,62 +9,67 @@ namespace Avalonia
     public static class EnumExtensions
     {
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe bool HasAllFlags<T>(this T value, T flag) where T : unmanaged, Enum
+        [Obsolete("This method is obsolete. Use HasAllFlags instead.")]
+        public static bool HasFlagCustom<T>(this T value, T flag) where T : unmanaged, Enum
+            => value.HasAllFlags(flag);
+            
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe bool HasAllFlags<T>(this T value, T flags) where T : unmanaged, Enum
         {
             if (sizeof(T) == 1)
             {
                 var byteValue = Unsafe.As<T, byte>(ref value);
-                var byteFlag = Unsafe.As<T, byte>(ref flag);
+                var byteFlags = Unsafe.As<T, byte>(ref flags);
-                return (byteValue & byteFlag) == byteFlag;
+                return (byteValue & byteFlags) == byteFlags;
             }
             else if (sizeof(T) == 2)
             {
                 var shortValue = Unsafe.As<T, short>(ref value);
-                var shortFlag = Unsafe.As<T, short>(ref flag);
+                var shortFlags = Unsafe.As<T, short>(ref flags);
-                return (shortValue & shortFlag) == shortFlag;
+                return (shortValue & shortFlags) == shortFlags;
             }
             else if (sizeof(T) == 4)
             {
                 var intValue = Unsafe.As<T, int>(ref value);
-                var intFlag = Unsafe.As<T, int>(ref flag);
+                var intFlags = Unsafe.As<T, int>(ref flags);
-                return (intValue & intFlag) == intFlag;
+                return (intValue & intFlags) == intFlags;
             }
             else if (sizeof(T) == 8)
             {
                 var longValue = Unsafe.As<T, long>(ref value);
-                var longFlag = Unsafe.As<T, long>(ref flag);
+                var longFlags = Unsafe.As<T, long>(ref flags);
-                return (longValue & longFlag) == longFlag;
+                return (longValue & longFlags) == longFlags;
             }
             else
                 throw new NotSupportedException("Enum with size of " + Unsafe.SizeOf<T>() + " are not supported");
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public static unsafe bool HasAnyFlag<T>(this T value, T flag) where T : unmanaged, Enum
+        public static unsafe bool HasAnyFlag<T>(this T value, T flags) where T : unmanaged, Enum
         {
             if (sizeof(T) == 1)
             {
                 var byteValue = Unsafe.As<T, byte>(ref value);
-                var byteFlag = Unsafe.As<T, byte>(ref flag);
+                var byteFlags = Unsafe.As<T, byte>(ref flags);
-                return (byteValue & byteFlag) != 0;
+                return (byteValue & byteFlags) != 0;
             }
             else if (sizeof(T) == 2)
             {
                 var shortValue = Unsafe.As<T, short>(ref value);
-                var shortFlag = Unsafe.As<T, short>(ref flag);
+                var shortFlags = Unsafe.As<T, short>(ref flags);
-                return (shortValue & shortFlag) != 0;
+                return (shortValue & shortFlags) != 0;
             }
             else if (sizeof(T) == 4)
             {
                 var intValue = Unsafe.As<T, int>(ref value);
-                var intFlag = Unsafe.As<T, int>(ref flag);
+                var intFlags = Unsafe.As<T, int>(ref flags);
-                return (intValue & intFlag) != 0;
+                return (intValue & intFlags) != 0;
             }
             else if (sizeof(T) == 8)
             {
                 var longValue = Unsafe.As<T, long>(ref value);
-                var longFlag = Unsafe.As<T, long>(ref flag);
+                var longFlags = Unsafe.As<T, long>(ref flags);
-                return (longValue & longFlag) != 0;
+                return (longValue & longFlags) != 0;
             }
             else
                 throw new NotSupportedException("Enum with size of " + Unsafe.SizeOf<T>() + " are not supported");