From e4575169332e6f8ab56491f9b44b0999f9a90fd3 Mon Sep 17 00:00:00 2001
From: Drew Noakes <git@drewnoakes.com>
Date: Wed, 24 Feb 2021 23:33:25 +1100
Subject: [PATCH] Avoid boxing while unpacking flags

Enum.HasFlag boxes its argument. Replace it with a method that does not.
---
 GitCommands/Git/GitItemStatus.cs | 34 +++++++++++++++++++-------------
 1 file changed, 20 insertions(+), 14 deletions(-)

diff --git a/GitCommands/Git/GitItemStatus.cs b/GitCommands/Git/GitItemStatus.cs
index 4c0c913fd94..522d53adee3 100644
--- a/GitCommands/Git/GitItemStatus.cs
+++ b/GitCommands/Git/GitItemStatus.cs
@@ -65,13 +65,13 @@ public GitItemStatus(string name)
 
         public bool IsTracked
         {
-            get => _flags.HasFlag(Flags.IsTracked);
+            get => HasFlag(Flags.IsTracked);
             set => SetFlag(value, Flags.IsTracked);
         }
 
         public bool IsDeleted
         {
-            get => _flags.HasFlag(Flags.IsDeleted);
+            get => HasFlag(Flags.IsDeleted);
             set => SetFlag(value, Flags.IsDeleted);
         }
 
@@ -81,55 +81,55 @@ public bool IsDeleted
         /// </summary>
         public bool IsChanged
         {
-            get => _flags.HasFlag(Flags.IsChanged);
+            get => HasFlag(Flags.IsChanged);
             set => SetFlag(value, Flags.IsChanged);
         }
 
         public bool IsNew
         {
-            get => _flags.HasFlag(Flags.IsNew);
+            get => HasFlag(Flags.IsNew);
             set => SetFlag(value, Flags.IsNew);
         }
 
         public bool IsIgnored
         {
-            get => _flags.HasFlag(Flags.IsIgnored);
+            get => HasFlag(Flags.IsIgnored);
             set => SetFlag(value, Flags.IsIgnored);
         }
 
         public bool IsRenamed
         {
-            get => _flags.HasFlag(Flags.IsRenamed);
+            get => HasFlag(Flags.IsRenamed);
             set => SetFlag(value, Flags.IsRenamed);
         }
 
         public bool IsCopied
         {
-            get => _flags.HasFlag(Flags.IsCopied);
+            get => HasFlag(Flags.IsCopied);
             set => SetFlag(value, Flags.IsCopied);
         }
 
         public bool IsConflict
         {
-            get => _flags.HasFlag(Flags.IsConflict);
+            get => HasFlag(Flags.IsConflict);
             set => SetFlag(value, Flags.IsConflict);
         }
 
         public bool IsAssumeUnchanged
         {
-            get => _flags.HasFlag(Flags.IsAssumeUnchanged);
+            get => HasFlag(Flags.IsAssumeUnchanged);
             set => SetFlag(value, Flags.IsAssumeUnchanged);
         }
 
         public bool IsSkipWorktree
         {
-            get => _flags.HasFlag(Flags.IsSkipWorktree);
+            get => HasFlag(Flags.IsSkipWorktree);
             set => SetFlag(value, Flags.IsSkipWorktree);
         }
 
         public bool IsSubmodule
         {
-            get => _flags.HasFlag(Flags.IsSubmodule);
+            get => HasFlag(Flags.IsSubmodule);
             set => SetFlag(value, Flags.IsSubmodule);
         }
 
@@ -139,7 +139,7 @@ public bool IsSubmodule
         /// </summary>
         public bool IsDirty
         {
-            get => _flags.HasFlag(Flags.IsDirty);
+            get => HasFlag(Flags.IsDirty);
             set => SetFlag(value, Flags.IsDirty);
         }
 
@@ -149,7 +149,7 @@ public bool IsDirty
         /// </remarks>
         public bool IsStatusOnly
         {
-            get => _flags.HasFlag(Flags.IsStatusOnly);
+            get => HasFlag(Flags.IsStatusOnly);
             set => SetFlag(value, Flags.IsStatusOnly);
         }
 
@@ -159,10 +159,16 @@ public bool IsStatusOnly
         /// </remarks>
         public bool IsRangeDiff
         {
-            get => _flags.HasFlag(Flags.IsRangeDiff);
+            get => HasFlag(Flags.IsRangeDiff);
             set => SetFlag(value, Flags.IsRangeDiff);
         }
 
+        private bool HasFlag(Flags flags)
+        {
+            // NOTE Enum.HasFlag boxes its argument
+            return (flags & _flags) == flags;
+        }
+
         private void SetFlag(bool isSet, Flags flag)
         {
             if (isSet)