Replace all usages of HasFlag with HasFlagFast

osu.Framework.Tests/Visual/Containers/TestSceneSafeAreaOverrides.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
···
 
         private void addBoxAssert(OverrideTestContainer container)
         {
-            bool leftOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlag(Edges.Left);
-            bool topOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlag(Edges.Top);
-            bool rightOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlag(Edges.Right);
-            bool bottomOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlag(Edges.Bottom);
+            bool leftOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlagFast(Edges.Left);
+            bool topOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlagFast(Edges.Top);
+            bool rightOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlagFast(Edges.Right);
+            bool bottomOverridden = container.SafeAreaContainer.SafeAreaOverrideEdges.HasFlagFast(Edges.Bottom);
 
             AddAssert($"\"{container.Name}\" overrides correctly", () =>
                 leftOverridden == container.SafeAreaContainer.Padding.Left < 0

osu.Framework.Tests/Visual/Drawables/TestSceneIsMaskedAway.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using NUnit.Framework;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Shapes;
···
                         Anchor = anchor,
                         Origin = anchor,
                         Size = new Vector2(10),
-                        Position = new Vector2(anchor.HasFlag(Anchor.x0) ? -5 : 5, anchor.HasFlag(Anchor.y0) ? -5 : 5),
+                        Position = new Vector2(anchor.HasFlagFast(Anchor.x0) ? -5 : 5, anchor.HasFlagFast(Anchor.y0) ? -5 : 5),
                     }
                 };
             });
···
                         Anchor = anchor,
                         Origin = anchor,
                         Size = new Vector2(10),
-                        Position = new Vector2(anchor.HasFlag(Anchor.x0) ? -20 : 20, anchor.HasFlag(Anchor.y0) ? -20 : 20),
+                        Position = new Vector2(anchor.HasFlagFast(Anchor.x0) ? -20 : 20, anchor.HasFlagFast(Anchor.y0) ? -20 : 20),
                     }
                 };
             });

osu.Framework.Tests/Visual/UserInterface/TestSceneContextMenu.cs

···
 using System;
 using System.Linq;
 using NUnit.Framework;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Graphics.Cursor;
···
             {
                 box.Anchor = anchor;
 
-                if (anchor.HasFlag(Anchor.x0))
+                if (anchor.HasFlagFast(Anchor.x0))
                     box.X -= contextMenuContainer.CurrentMenu.DrawWidth + 10;
-                else if (anchor.HasFlag(Anchor.x2))
+                else if (anchor.HasFlagFast(Anchor.x2))
                     box.X += 10;
 
-                if (anchor.HasFlag(Anchor.y0))
+                if (anchor.HasFlagFast(Anchor.y0))
                     box.Y -= contextMenuContainer.CurrentMenu.DrawHeight + 10;
-                else if (anchor.HasFlag(Anchor.y2))
+                else if (anchor.HasFlagFast(Anchor.y2))
                     box.Y += 10;
             });
 

osu.Framework/Extensions/EnumExtensions/EnumExtensions.cs

···
             });
         }
 
+#pragma warning disable RS0030 // (banned API)
         /// <summary>
         /// A fast alternative functionally equivalent to <see cref="Enum.HasFlag"/>, eliminating boxing in all scenarios.
         /// </summary>
         /// <param name="enumValue">The enum to check.</param>
         /// <param name="flag">The flag to check for.</param>
+#pragma warning restore RS0030
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe bool HasFlagFast<T>(this T enumValue, T flag) where T : unmanaged, Enum
         {

osu.Framework/Graphics/Containers/AudioContainer.cs

···
 using System.Collections;
 using System.Collections.Generic;
 using osu.Framework.Audio;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Audio;
 using osu.Framework.Graphics.Effects;
 using osuTK;
···
             set
             {
                 base.Size = new Vector2(
-                    RelativeSizeAxes.HasFlag(Axes.X) ? 1 : value.X,
-                    RelativeSizeAxes.HasFlag(Axes.Y) ? 1 : value.Y);
+                    RelativeSizeAxes.HasFlagFast(Axes.X) ? 1 : value.X,
+                    RelativeSizeAxes.HasFlagFast(Axes.Y) ? 1 : value.Y);
 
                 container.Size = value;
             }

osu.Framework/Graphics/Containers/CompositeDrawable.cs

···
 using System.Threading.Tasks;
 using JetBrains.Annotations;
 using osu.Framework.Development;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Extensions.ExceptionExtensions;
 using osu.Framework.Graphics.Effects;
 using osu.Framework.Graphics.Primitives;
···
             {
                 var state = checkChildLife(internalChildren[i]);
 
-                anyAliveChanged |= state.HasFlag(ChildLifeStateChange.MadeAlive) || state.HasFlag(ChildLifeStateChange.MadeDead);
+                anyAliveChanged |= state.HasFlagFast(ChildLifeStateChange.MadeAlive) || state.HasFlagFast(ChildLifeStateChange.MadeDead);
 
-                if (state.HasFlag(ChildLifeStateChange.Removed))
+                if (state.HasFlagFast(ChildLifeStateChange.Removed))
                     i--;
             }
 
···
         {
             get
             {
-                if (!isComputingChildrenSizeDependencies && AutoSizeAxes.HasFlag(Axes.X))
+                if (!isComputingChildrenSizeDependencies && AutoSizeAxes.HasFlagFast(Axes.X))
                     updateChildrenSizeDependencies();
                 return base.Width;
             }
···
         {
             get
             {
-                if (!isComputingChildrenSizeDependencies && AutoSizeAxes.HasFlag(Axes.Y))
+                if (!isComputingChildrenSizeDependencies && AutoSizeAxes.HasFlagFast(Axes.Y))
                     updateChildrenSizeDependencies();
                 return base.Height;
             }
···
 
                     Vector2 cBound = c.RequiredParentSizeToFit;
 
-                    if (!c.BypassAutoSizeAxes.HasFlag(Axes.X))
+                    if (!c.BypassAutoSizeAxes.HasFlagFast(Axes.X))
                         maxBoundSize.X = Math.Max(maxBoundSize.X, cBound.X);
 
-                    if (!c.BypassAutoSizeAxes.HasFlag(Axes.Y))
+                    if (!c.BypassAutoSizeAxes.HasFlagFast(Axes.Y))
                         maxBoundSize.Y = Math.Max(maxBoundSize.Y, cBound.Y);
                 }
 
-                if (!AutoSizeAxes.HasFlag(Axes.X))
+                if (!AutoSizeAxes.HasFlagFast(Axes.X))
                     maxBoundSize.X = DrawSize.X;
-                if (!AutoSizeAxes.HasFlag(Axes.Y))
+                if (!AutoSizeAxes.HasFlagFast(Axes.Y))
                     maxBoundSize.Y = DrawSize.Y;
 
                 return new Vector2(maxBoundSize.X, maxBoundSize.Y);
···
             Vector2 b = computeAutoSize() + Padding.Total;
 
             autoSizeResizeTo(new Vector2(
-                AutoSizeAxes.HasFlag(Axes.X) ? b.X : base.Width,
-                AutoSizeAxes.HasFlag(Axes.Y) ? b.Y : base.Height
+                AutoSizeAxes.HasFlagFast(Axes.X) ? b.X : base.Width,
+                AutoSizeAxes.HasFlagFast(Axes.Y) ? b.Y : base.Height
             ), AutoSizeDuration, AutoSizeEasing);
 
             //note that this is called before autoSize becomes valid. may be something to consider down the line.

osu.Framework/Graphics/Containers/ContainerExtensions.cs

···
 using osuTK;
 using System;
 using System.Collections.Generic;
+using osu.Framework.Extensions.EnumExtensions;
 
 namespace osu.Framework.Graphics.Containers
 {
···
 
             // For anchor/origin positioning to be preserved correctly,
             // relatively sized axes must be lifted to the wrapping container.
-            if (container.RelativeSizeAxes.HasFlag(Axes.X))
+            if (container.RelativeSizeAxes.HasFlagFast(Axes.X))
             {
                 container.Width = drawable.Width;
                 drawable.Width = 1;
             }
 
-            if (container.RelativeSizeAxes.HasFlag(Axes.Y))
+            if (container.RelativeSizeAxes.HasFlagFast(Axes.Y))
             {
                 container.Height = drawable.Height;
                 drawable.Height = 1;

osu.Framework/Graphics/Containers/FillFlowContainer.cs

···
 using System.Collections.Generic;
 using osuTK;
 using System.Linq;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Utils;
 
 namespace osu.Framework.Graphics.Containers
···
         private Vector2 spacingFactor(Drawable c)
         {
             Vector2 result = c.RelativeOriginPosition;
-            if (c.Anchor.HasFlag(Anchor.x2))
+            if (c.Anchor.HasFlagFast(Anchor.x2))
                 result.X = 1 - result.X;
-            if (c.Anchor.HasFlag(Anchor.y2))
+            if (c.Anchor.HasFlagFast(Anchor.y2))
                 result.Y = 1 - result.Y;
             return result;
         }
···
 
                 // If we are autosize and haven't specified a maximum size, we should allow infinite expansion.
                 // If we are inheriting then we need to use the parent size (our ActualSize).
-                max.X = AutoSizeAxes.HasFlag(Axes.X) ? float.MaxValue : s.X;
-                max.Y = AutoSizeAxes.HasFlag(Axes.Y) ? float.MaxValue : s.Y;
+                max.X = AutoSizeAxes.HasFlagFast(Axes.X) ? float.MaxValue : s.X;
+                max.Y = AutoSizeAxes.HasFlagFast(Axes.Y) ? float.MaxValue : s.Y;
             }
 
             var children = FlowingChildren.ToArray();
···
                         break;
                 }
 
-                if (c.Anchor.HasFlag(Anchor.x1))
+                if (c.Anchor.HasFlagFast(Anchor.x1))
                     // Begin flow at centre of row
                     result[i].X += rowOffsetsToMiddle[rowIndices[i]];
-                else if (c.Anchor.HasFlag(Anchor.x2))
+                else if (c.Anchor.HasFlagFast(Anchor.x2))
                     // Flow right-to-left
                     result[i].X = -result[i].X;
 
-                if (c.Anchor.HasFlag(Anchor.y1))
+                if (c.Anchor.HasFlagFast(Anchor.y1))
                     // Begin flow at centre of total height
                     result[i].Y -= height / 2;
-                else if (c.Anchor.HasFlag(Anchor.y2))
+                else if (c.Anchor.HasFlagFast(Anchor.y2))
                     // Flow bottom-to-top
                     result[i].Y = -result[i].Y;
             }

osu.Framework/Graphics/Containers/Markdown/MarkdownContainer.cs

···
 using Markdig.Syntax.Inlines;
 using osu.Framework.Allocation;
 using osu.Framework.Caching;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Sprites;
 using osuTK;
 
···
             get => base.AutoSizeAxes;
             set
             {
-                if (value.HasFlag(Axes.X))
+                if (value.HasFlagFast(Axes.X))
                     throw new ArgumentException($"{nameof(MarkdownContainer)} does not support an {nameof(AutoSizeAxes)} of {value}");
 
                 base.AutoSizeAxes = value;

osu.Framework/Graphics/Containers/SafeAreaContainer.cs

···
 using System;
 using osu.Framework.Allocation;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Primitives;
 using osu.Framework.Layout;
 
···
 
             return new MarginPadding
             {
-                Left = SafeAreaOverrideEdges.HasFlag(Edges.Left) ? nonSafeLocalSpace.TopLeft.X : Math.Clamp(localTopLeft.X, 0, DrawSize.X),
-                Right = SafeAreaOverrideEdges.HasFlag(Edges.Right) ? DrawRectangle.BottomRight.X - nonSafeLocalSpace.BottomRight.X : Math.Clamp(DrawSize.X - localBottomRight.X, 0, DrawSize.X),
-                Top = SafeAreaOverrideEdges.HasFlag(Edges.Top) ? nonSafeLocalSpace.TopLeft.Y : Math.Clamp(localTopLeft.Y, 0, DrawSize.Y),
-                Bottom = SafeAreaOverrideEdges.HasFlag(Edges.Bottom) ? DrawRectangle.BottomRight.Y - nonSafeLocalSpace.BottomRight.Y : Math.Clamp(DrawSize.Y - localBottomRight.Y, 0, DrawSize.Y)
+                Left = SafeAreaOverrideEdges.HasFlagFast(Edges.Left) ? nonSafeLocalSpace.TopLeft.X : Math.Clamp(localTopLeft.X, 0, DrawSize.X),
+                Right = SafeAreaOverrideEdges.HasFlagFast(Edges.Right) ? DrawRectangle.BottomRight.X - nonSafeLocalSpace.BottomRight.X : Math.Clamp(DrawSize.X - localBottomRight.X, 0, DrawSize.X),
+                Top = SafeAreaOverrideEdges.HasFlagFast(Edges.Top) ? nonSafeLocalSpace.TopLeft.Y : Math.Clamp(localTopLeft.Y, 0, DrawSize.Y),
+                Bottom = SafeAreaOverrideEdges.HasFlagFast(Edges.Bottom) ? DrawRectangle.BottomRight.Y - nonSafeLocalSpace.BottomRight.Y : Math.Clamp(DrawSize.Y - localBottomRight.Y, 0, DrawSize.Y)
             };
         }
     }

osu.Framework/Graphics/Containers/TextFlowContainer.cs

···
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
+using osu.Framework.Extensions.EnumExtensions;
 
 namespace osu.Framework.Graphics.Containers
 {
···
         {
             // FillFlowContainer will reverse the ordering of right-anchored words such that the (previously) first word would be
             // the right-most word, whereas it should still be flowed left-to-right. This is achieved by reversing the comparator.
-            if (TextAnchor.HasFlag(Anchor.x2))
+            if (TextAnchor.HasFlagFast(Anchor.x2))
                 return base.Compare(y, x);
 
             return base.Compare(x, y);

osu.Framework/Graphics/Drawable.cs

···
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Development;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Cursor;
 using osu.Framework.Graphics.OpenGL;
 using osu.Framework.Input.Bindings;
···
                 {
                     offset = Parent.RelativeChildOffset;
 
-                    if (!RelativePositionAxes.HasFlag(Axes.X))
+                    if (!RelativePositionAxes.HasFlagFast(Axes.X))
                         offset.X = 0;
 
-                    if (!RelativePositionAxes.HasFlag(Axes.Y))
+                    if (!RelativePositionAxes.HasFlagFast(Axes.Y))
                         offset.Y = 0;
                 }
 
···
 
                 relativeSizeAxes = value;
 
-                if (relativeSizeAxes.HasFlag(Axes.X) && Width == 0) Width = 1;
-                if (relativeSizeAxes.HasFlag(Axes.Y) && Height == 0) Height = 1;
+                if (relativeSizeAxes.HasFlagFast(Axes.X) && Width == 0) Width = 1;
+                if (relativeSizeAxes.HasFlagFast(Axes.Y) && Height == 0) Height = 1;
 
                 updateBypassAutoSizeAxes();
 
···
             {
                 Vector2 conversion = relativeToAbsoluteFactor;
 
-                if (relativeAxes.HasFlag(Axes.X))
+                if (relativeAxes.HasFlagFast(Axes.X))
                     v.X *= conversion.X;
-                if (relativeAxes.HasFlag(Axes.Y))
+                if (relativeAxes.HasFlagFast(Axes.Y))
                     v.Y *= conversion.Y;
 
                 // FillMode only makes sense if both axes are relatively sized as the general rule
···
                     throw new InvalidOperationException(@"Can not obtain relative origin position for custom origins.");
 
                 Vector2 result = Vector2.Zero;
-                if (origin.HasFlag(Anchor.x1))
+                if (origin.HasFlagFast(Anchor.x1))
                     result.X = 0.5f;
-                else if (origin.HasFlag(Anchor.x2))
+                else if (origin.HasFlagFast(Anchor.x2))
                     result.X = 1;
 
-                if (origin.HasFlag(Anchor.y1))
+                if (origin.HasFlagFast(Anchor.y1))
                     result.Y = 0.5f;
-                else if (origin.HasFlag(Anchor.y2))
+                else if (origin.HasFlagFast(Anchor.y2))
                     result.Y = 1;
 
                 return result;
···
                     return customRelativeAnchorPosition;
 
                 Vector2 result = Vector2.Zero;
-                if (anchor.HasFlag(Anchor.x1))
+                if (anchor.HasFlagFast(Anchor.x1))
                     result.X = 0.5f;
-                else if (anchor.HasFlag(Anchor.x2))
+                else if (anchor.HasFlagFast(Anchor.x2))
                     result.X = 1;
 
-                if (anchor.HasFlag(Anchor.y1))
+                if (anchor.HasFlagFast(Anchor.y1))
                     result.Y = 0.5f;
-                else if (anchor.HasFlag(Anchor.y2))
+                else if (anchor.HasFlagFast(Anchor.y2))
                     result.Y = 1;
 
                 return result;
···
         {
             Vector2 result = Vector2.Zero;
 
-            if (anchor.HasFlag(Anchor.x1))
+            if (anchor.HasFlagFast(Anchor.x1))
                 result.X = size.X / 2f;
-            else if (anchor.HasFlag(Anchor.x2))
+            else if (anchor.HasFlagFast(Anchor.x2))
                 result.X = size.X;
 
-            if (anchor.HasFlag(Anchor.y1))
+            if (anchor.HasFlagFast(Anchor.y1))
                 result.Y = size.Y / 2f;
-            else if (anchor.HasFlag(Anchor.y2))
+            else if (anchor.HasFlagFast(Anchor.y2))
                 result.Y = size.Y;
 
             return result;

osu.Framework/Graphics/Lines/Path.cs

···
 using osu.Framework.Allocation;
 using System.Collections.Generic;
 using osu.Framework.Caching;
+using osu.Framework.Extensions.EnumExtensions;
 using osuTK.Graphics;
 using osuTK.Graphics.ES30;
 
···
         {
             get
             {
-                if (AutoSizeAxes.HasFlag(Axes.X))
+                if (AutoSizeAxes.HasFlagFast(Axes.X))
                     return base.Width = vertexBounds.Width;
 
                 return base.Width;
···
         {
             get
             {
-                if (AutoSizeAxes.HasFlag(Axes.Y))
+                if (AutoSizeAxes.HasFlagFast(Axes.Y))
                     return base.Height = vertexBounds.Height;
 
                 return base.Height;

osu.Framework/Graphics/Pooling/PoolableDrawable.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Layout;
 using osu.Framework.Threading;
···
 
         protected override bool OnInvalidate(Invalidation invalidation, InvalidationSource source)
         {
-            if (source != InvalidationSource.Child && invalidation.HasFlag(Invalidation.Parent))
+            if (source != InvalidationSource.Child && invalidation.HasFlagFast(Invalidation.Parent))
             {
                 if (IsInUse && Parent == null)
                     Return();

osu.Framework/Graphics/Textures/Texture.cs

···
 
 using System;
 using System.IO;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Batches;
 using osu.Framework.Graphics.OpenGL.Textures;
 using osu.Framework.Graphics.Primitives;
···
             if (relativeSizeAxes != Axes.None)
             {
                 Vector2 scale = new Vector2(
-                    relativeSizeAxes.HasFlag(Axes.X) ? Width : 1,
-                    relativeSizeAxes.HasFlag(Axes.Y) ? Height : 1
+                    relativeSizeAxes.HasFlagFast(Axes.X) ? Width : 1,
+                    relativeSizeAxes.HasFlagFast(Axes.Y) ? Height : 1
                 );
                 cropRectangle *= scale;
             }

osu.Framework/Graphics/UserInterface/Menu.cs

···
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Extensions.IEnumerableExtensions;
 using osuTK.Graphics;
 using osu.Framework.Graphics.Containers;
···
                 height = Math.Min(MaxHeight, height);
 
                 // Regardless of the above result, if we are relative-sizing, just use the stored width/height
-                width = RelativeSizeAxes.HasFlag(Axes.X) ? Width : width;
-                height = RelativeSizeAxes.HasFlag(Axes.Y) ? Height : height;
+                width = RelativeSizeAxes.HasFlagFast(Axes.X) ? Width : width;
+                height = RelativeSizeAxes.HasFlagFast(Axes.Y) ? Height : height;
 
                 if (State == MenuState.Closed && Direction == Direction.Horizontal)
                     width = 0;

osu.Framework/Graphics/UserInterface/TabControl.cs

···
 using System.Linq;
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Graphics.Containers;
 using osu.Framework.Input;
 using osu.Framework.Input.Bindings;
···
 
                 AddInternal(Dropdown);
 
-                Trace.Assert(Dropdown.Header.Anchor.HasFlag(Anchor.x2), $@"The {nameof(Dropdown)} implementation should use a right-based anchor inside a TabControl.");
-                Trace.Assert(!Dropdown.Header.RelativeSizeAxes.HasFlag(Axes.X), $@"The {nameof(Dropdown)} implementation's header should have a specific size.");
+                Trace.Assert(Dropdown.Header.Anchor.HasFlagFast(Anchor.x2), $@"The {nameof(Dropdown)} implementation should use a right-based anchor inside a TabControl.");
+                Trace.Assert(!Dropdown.Header.RelativeSizeAxes.HasFlagFast(Axes.X), $@"The {nameof(Dropdown)} implementation's header should have a specific size.");
             }
 
             AddInternal(TabContainer = CreateTabFlow());

osu.Framework/Input/Handlers/Mouse/OsuTKMouseState.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Extensions.EnumExtensions;
 using osuTK;
 using osuTK.Input;
 
···
             }
 
             Scroll = new Vector2(-tkState.Scroll.X, tkState.Scroll.Y);
-            HasPreciseScroll = tkState.Flags.HasFlag(MouseStateFlags.HasPreciseScroll);
+            HasPreciseScroll = tkState.Flags.HasFlagFast(MouseStateFlags.HasPreciseScroll);
             Position = new Vector2(mappedPosition?.X ?? tkState.X, mappedPosition?.Y ?? tkState.Y);
         }
 

osu.Framework/Input/Handlers/Mouse/OsuTKRawMouseHandler.cs

···
 using System.Linq;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Platform;
 using osu.Framework.Threading;
 using osuTK;
···
 
                                 var newState = new OsuTKPollMouseState(rawState, host.IsActive.Value, getUpdatedPosition(rawState, lastState));
 
-                                HandleState(newState, lastState, rawState.Flags.HasFlag(MouseStateFlags.MoveAbsolute));
+                                HandleState(newState, lastState, rawState.Flags.HasFlagFast(MouseStateFlags.MoveAbsolute));
 
                                 lastEachDeviceStates[i] = newState;
                                 lastUnfocusedState = null;
···
         {
             Vector2 currentPosition;
 
-            if (state.Flags.HasFlag(MouseStateFlags.MoveAbsolute))
+            if (state.Flags.HasFlagFast(MouseStateFlags.MoveAbsolute))
             {
                 const int raw_input_resolution = 65536;
 
···
                 }
                 else
                 {
-                    Rectangle screenRect = state.Flags.HasFlag(MouseStateFlags.VirtualDesktop)
+                    Rectangle screenRect = state.Flags.HasFlagFast(MouseStateFlags.VirtualDesktop)
                         ? Platform.Windows.Native.Input.GetVirtualScreenRect()
                         : new Rectangle(0, 0, DisplayDevice.Default.Width, DisplayDevice.Default.Height);
 

osu.Framework/Input/UserInputManager.cs

···
 // See the LICENCE file in the repository root for full licence text.
 
 using System.Collections.Immutable;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Input.Handlers;
 using osu.Framework.Input.StateChanges;
 using osu.Framework.Input.StateChanges.Events;
···
                     var mouse = mousePositionChange.State.Mouse;
 
                     // confine cursor
-                    if (Host.Window != null && Host.Window.CursorState.HasFlag(CursorState.Confined))
+                    if (Host.Window != null && Host.Window.CursorState.HasFlagFast(CursorState.Confined))
                     {
                         var clientSize = Host.Window.ClientSize;
                         mouse.Position = Vector2.Clamp(mouse.Position, Vector2.Zero, new Vector2(clientSize.Width, clientSize.Height));

osu.Framework/Platform/MacOS/OsuTKMacOSWindow.cs

···
 using osu.Framework.Platform.MacOS.Native;
 using osuTK;
 using System.Diagnostics;
+using osu.Framework.Extensions.EnumExtensions;
 
 namespace osu.Framework.Platform.MacOS
 {
···
         private const NSApplicationPresentationOptions default_fullscreen_presentation_options =
             NSApplicationPresentationOptions.AutoHideDock | NSApplicationPresentationOptions.AutoHideMenuBar | NSApplicationPresentationOptions.FullScreen;
 
-        private bool isCursorHidden => CursorState.HasFlag(CursorState.Hidden);
+        private bool isCursorHidden => CursorState.HasFlagFast(CursorState.Hidden);
 
         private NSApplicationPresentationOptions fullscreenPresentationOptions =>
             default_fullscreen_presentation_options | (isCursorHidden ? NSApplicationPresentationOptions.DisableCursorLocationAssistance : 0);
···
             {
                 pendingWindowMode = null;
 
-                bool currentFullScreen = styleMask.HasFlag(NSWindowStyleMask.FullScreen);
+                bool currentFullScreen = styleMask.HasFlagFast(NSWindowStyleMask.FullScreen);
                 bool toggleFullScreen = mode.Value == Configuration.WindowMode.Fullscreen ? !currentFullScreen : currentFullScreen;
 
                 if (toggleFullScreen)
···
             {
                 case MacOSKeyCodes.LShift:
                     key = osuTK.Input.Key.LShift;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.LeftShift);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.LeftShift);
                     break;
 
                 case MacOSKeyCodes.RShift:
                     key = osuTK.Input.Key.RShift;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.RightShift);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.RightShift);
                     break;
 
                 case MacOSKeyCodes.LControl:
                     key = osuTK.Input.Key.LControl;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.LeftControl);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.LeftControl);
                     break;
 
                 case MacOSKeyCodes.RControl:
                     key = osuTK.Input.Key.RControl;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.RightControl);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.RightControl);
                     break;
 
                 case MacOSKeyCodes.LAlt:
                     key = osuTK.Input.Key.LAlt;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.LeftAlt);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.LeftAlt);
                     break;
 
                 case MacOSKeyCodes.RAlt:
                     key = osuTK.Input.Key.RAlt;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.RightAlt);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.RightAlt);
                     break;
 
                 case MacOSKeyCodes.LCommand:
                     key = osuTK.Input.Key.LWin;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.LeftCommand);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.LeftCommand);
                     break;
 
                 case MacOSKeyCodes.RCommand:
                     key = osuTK.Input.Key.RWin;
-                    keyDown = modifierFlags.HasFlag(CocoaKeyModifiers.RightCommand);
+                    keyDown = modifierFlags.HasFlagFast(CocoaKeyModifiers.RightCommand);
                     break;
 
                 default:

osu.Framework/Platform/OsuTKWindow.cs

···
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Extensions;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Threading;
 
 namespace osu.Framework.Platform
···
             {
                 cursorState = value;
 
-                OsuTKGameWindow.Cursor = cursorState.HasFlag(CursorState.Hidden) ? MouseCursor.Empty : MouseCursor.Default;
+                OsuTKGameWindow.Cursor = cursorState.HasFlagFast(CursorState.Hidden) ? MouseCursor.Empty : MouseCursor.Default;
 
                 try
                 {
-                    OsuTKGameWindow.CursorGrabbed = cursorState.HasFlag(CursorState.Confined);
+                    OsuTKGameWindow.CursorGrabbed = cursorState.HasFlagFast(CursorState.Confined);
                 }
                 catch
                 {

osu.Framework/Platform/SDL2/SDL2Extensions.cs

···
 // Copyright (c) ppy Pty Ltd <[e-mail]>. Licensed under the MIT Licence.
 // See the LICENCE file in the repository root for full licence text.
 
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Input;
 using osuTK.Input;
 using SDL2;
···
         {
             // Apple devices don't have the notion of NumLock (they have a Clear key instead).
             // treat them as if they always have NumLock on (the numpad always performs its primary actions).
-            bool numLockOn = sdlKeysym.mod.HasFlag(SDL.SDL_Keymod.KMOD_NUM) || RuntimeInfo.IsApple;
+            bool numLockOn = sdlKeysym.mod.HasFlagFast(SDL.SDL_Keymod.KMOD_NUM) || RuntimeInfo.IsApple;
 
             switch (sdlKeysym.scancode)
             {
···
         public static WindowState ToWindowState(this SDL.SDL_WindowFlags windowFlags)
         {
             // NOTE: on macOS, SDL2 does not differentiate between "maximised" and "fullscreen desktop"
-            if (windowFlags.HasFlag(SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP) ||
-                windowFlags.HasFlag(SDL.SDL_WindowFlags.SDL_WINDOW_BORDERLESS) ||
-                windowFlags.HasFlag(SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED) && RuntimeInfo.OS == RuntimeInfo.Platform.MacOsx)
+            if (windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN_DESKTOP) ||
+                windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_BORDERLESS) ||
+                windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED) && RuntimeInfo.OS == RuntimeInfo.Platform.MacOsx)
                 return WindowState.FullscreenBorderless;
 
-            if (windowFlags.HasFlag(SDL.SDL_WindowFlags.SDL_WINDOW_MINIMIZED))
+            if (windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_MINIMIZED))
                 return WindowState.Minimised;
 
-            if (windowFlags.HasFlag(SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN))
+            if (windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_FULLSCREEN))
                 return WindowState.Fullscreen;
 
-            if (windowFlags.HasFlag(SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED))
+            if (windowFlags.HasFlagFast(SDL.SDL_WindowFlags.SDL_WINDOW_MAXIMIZED))
                 return WindowState.Maximised;
 
             return WindowState.Normal;

osu.Framework/Platform/SDL2DesktopWindow.cs

···
 using JetBrains.Annotations;
 using osu.Framework.Bindables;
 using osu.Framework.Configuration;
+using osu.Framework.Extensions.EnumExtensions;
 using osu.Framework.Extensions.ImageExtensions;
 using osu.Framework.Input;
 using osu.Framework.Platform.SDL2;
···
 
             CursorStateBindable.ValueChanged += evt =>
             {
-                CursorVisible = !evt.NewValue.HasFlag(CursorState.Hidden);
-                CursorConfined = evt.NewValue.HasFlag(CursorState.Confined);
+                CursorVisible = !evt.NewValue.HasFlagFast(CursorState.Hidden);
+                CursorConfined = evt.NewValue.HasFlagFast(CursorState.Confined);
             };
 
             cursorInWindow.ValueChanged += evt =>