Avoid boxing in FrugalList (#4724)

stephentoub · web-flow · commit 745c14933f43 · 2021-08-17T09:33:10.000-07:00
All comparisons are being performed with object.Equals(object).  If T is a value type, every comparison ends up boxing the argument.
diff --git a/src/Microsoft.DotNet.Wpf/src/Shared/MS/Utility/FrugalList.cs b/src/Microsoft.DotNet.Wpf/src/Shared/MS/Utility/FrugalList.cs
@@ -265,12 +265,12 @@ public override void Clear()
 
         public override bool Contains(T value)
         {
-            return _loneEntry.Equals(value);
+            return EqualityComparer<T>.Default.Equals(_loneEntry, value);
         }
 
         public override int IndexOf(T value)
         {
-            if (_loneEntry.Equals(value))
+            if (EqualityComparer<T>.Default.Equals(_loneEntry, value))
             {
                 return 0;
             }
@@ -298,7 +298,7 @@ public override void SetAt(int index, T value)
         public override bool Remove(T value)
         {
             // Wipe out the info in the only entry if it matches the item.
-            if (_loneEntry.Equals(value))
+            if (EqualityComparer<T>.Default.Equals(_loneEntry, value))
             {
                 _loneEntry = default(T);
                 --_count;
@@ -440,17 +440,17 @@ public override bool Contains(T value)
 
         public override int IndexOf(T value)
         {
-            if (_entry0.Equals(value))
+            if (EqualityComparer<T>.Default.Equals(_entry0, value))
             {
                 return 0;
             }
             if (_count > 1)
             {
-                if (_entry1.Equals(value))
+                if (EqualityComparer<T>.Default.Equals(_entry1, value))
                 {
                     return 1;
                 }
-                if ((3 == _count) && (_entry2.Equals(value)))
+                if ((3 == _count) && EqualityComparer<T>.Default.Equals(_entry2, value))
                 {
                     return 2;
                 }
@@ -516,19 +516,19 @@ public override bool Remove(T value)
             // If the item matches an existing entry, wipe out the last
             // entry and move all the other entries up.  Because we only
             // have three entries we can just unravel all the cases.
-            if (_entry0.Equals(value))
+            if (EqualityComparer<T>.Default.Equals(_entry0, value))
             {
                 RemoveAt(0);
                 return true;
             }
             else if ( _count > 1)
             {
-                if (_entry1.Equals(value))
+                if (EqualityComparer<T>.Default.Equals(_entry1, value))
                 {
                     RemoveAt(1);
                     return true;
                 }
-                else if ((3 == _count) && (_entry2.Equals(value)))
+                else if ((3 == _count) && EqualityComparer<T>.Default.Equals(_entry2, value))
                 {
                     RemoveAt(2);
                     return true;
@@ -781,35 +781,35 @@ public override bool Contains(T value)
 
         public override int IndexOf(T value)
         {
-            if (_entry0.Equals(value))
+            if (EqualityComparer<T>.Default.Equals(_entry0, value))
             {
                 return 0;
             }
             if (_count > 1)
             {
-                if (_entry1.Equals(value))
+                if (EqualityComparer<T>.Default.Equals(_entry1, value))
                 {
                     return 1;
                 }
                 if (_count > 2)
                 {
-                    if (_entry2.Equals(value))
+                    if (EqualityComparer<T>.Default.Equals(_entry2, value))
                     {
                         return 2;
                     }
                     if (_count > 3)
                     {
-                        if (_entry3.Equals(value))
+                        if (EqualityComparer<T>.Default.Equals(_entry3, value))
                         {
                             return 3;
                         }
                         if (_count > 4)
                         {
-                            if (_entry4.Equals(value))
+                            if (EqualityComparer<T>.Default.Equals(_entry4, value))
                             {
                                 return 4;
                             }
-                            if ((6 == _count) && (_entry5.Equals(value)))
+                            if ((6 == _count) && EqualityComparer<T>.Default.Equals(_entry5, value))
                             {
                                 return 5;
                             }
@@ -914,40 +914,40 @@ public override bool Remove(T value)
             // If the item matches an existing entry, wipe out the last
             // entry and move all the other entries up.  Because we only
             // have six entries we can just unravel all the cases.
-            if (_entry0.Equals(value))
+            if (EqualityComparer<T>.Default.Equals(_entry0, value))
             {
                 RemoveAt(0);
                 return true;
             }
             else if (_count > 1)
             {
-                if (_entry1.Equals(value))
+                if (EqualityComparer<T>.Default.Equals(_entry1, value))
                 {
                     RemoveAt(1);
                     return true;
                 }
                 else if (_count > 2)
                 {
-                    if (_entry2.Equals(value))
+                    if (EqualityComparer<T>.Default.Equals(_entry2, value))
                     {
                         RemoveAt(2);
                         return true;
                     }
                     else if (_count > 3)
                     {
-                        if (_entry3.Equals(value))
+                        if (EqualityComparer<T>.Default.Equals(_entry3, value))
                         {
                             RemoveAt(3);
                             return true;
                         }
                         else if (_count > 4)
                         {
-                            if (_entry4.Equals(value))
+                            if (EqualityComparer<T>.Default.Equals(_entry4, value))
                             {
                                 RemoveAt(4);
                                 return true;
                             }
-                            else if ((6 == _count) && (_entry5.Equals(value)))
+                            else if ((6 == _count) && EqualityComparer<T>.Default.Equals(_entry5, value))
                             {
                                 RemoveAt(5);
                                 return true;
@@ -1392,7 +1392,7 @@ public override int IndexOf(T value)
         {
             for (int index = 0; index < _count; ++index)
             {
-                if (_entries[index].Equals(value))
+                if (EqualityComparer<T>.Default.Equals(_entries[index], value))
                 {
                     return index;
                 }
@@ -1425,7 +1425,7 @@ public override bool Remove(T value)
         {
             for (int index = 0; index < _count; ++index)
             {
-                if (_entries[index].Equals(value))
+                if (EqualityComparer<T>.Default.Equals(_entries[index], value))
                 {
                     RemoveAt(index);
                     return true;

Original file line number	Diff line number	Diff line change
`@@ -265,12 +265,12 @@ public override void Clear()`
`265`	`265`
`266`	`266`	`public override bool Contains(T value)`
`267`	`267`	`{`
`268`		`- return _loneEntry.Equals(value);`
	`268`	`+ return EqualityComparer<T>.Default.Equals(_loneEntry, value);`
`269`	`269`	`}`
`270`	`270`
`271`	`271`	`public override int IndexOf(T value)`
`272`	`272`	`{`
`273`		`- if (_loneEntry.Equals(value))`
	`273`	`+ if (EqualityComparer<T>.Default.Equals(_loneEntry, value))`
`274`	`274`	`{`
`275`	`275`	`return 0;`
`276`	`276`	`}`
`@@ -298,7 +298,7 @@ public override void SetAt(int index, T value)`
`298`	`298`	`public override bool Remove(T value)`
`299`	`299`	`{`
`300`	`300`	`// Wipe out the info in the only entry if it matches the item.`
`301`		`- if (_loneEntry.Equals(value))`
	`301`	`+ if (EqualityComparer<T>.Default.Equals(_loneEntry, value))`
`302`	`302`	`{`
`303`	`303`	`_loneEntry = default(T);`
`304`	`304`	`--_count;`
`@@ -440,17 +440,17 @@ public override bool Contains(T value)`
`440`	`440`
`441`	`441`	`public override int IndexOf(T value)`
`442`	`442`	`{`
`443`		`- if (_entry0.Equals(value))`
	`443`	`+ if (EqualityComparer<T>.Default.Equals(_entry0, value))`
`444`	`444`	`{`
`445`	`445`	`return 0;`
`446`	`446`	`}`
`447`	`447`	`if (_count > 1)`
`448`	`448`	`{`
`449`		`- if (_entry1.Equals(value))`
	`449`	`+ if (EqualityComparer<T>.Default.Equals(_entry1, value))`
`450`	`450`	`{`
`451`	`451`	`return 1;`
`452`	`452`	`}`
`453`		`- if ((3 == _count) && (_entry2.Equals(value)))`
	`453`	`+ if ((3 == _count) && EqualityComparer<T>.Default.Equals(_entry2, value))`
`454`	`454`	`{`
`455`	`455`	`return 2;`
`456`	`456`	`}`
`@@ -516,19 +516,19 @@ public override bool Remove(T value)`
`516`	`516`	`// If the item matches an existing entry, wipe out the last`
`517`	`517`	`// entry and move all the other entries up. Because we only`
`518`	`518`	`// have three entries we can just unravel all the cases.`
`519`		`- if (_entry0.Equals(value))`
	`519`	`+ if (EqualityComparer<T>.Default.Equals(_entry0, value))`
`520`	`520`	`{`
`521`	`521`	`RemoveAt(0);`
`522`	`522`	`return true;`
`523`	`523`	`}`
`524`	`524`	`else if ( _count > 1)`
`525`	`525`	`{`
`526`		`- if (_entry1.Equals(value))`
	`526`	`+ if (EqualityComparer<T>.Default.Equals(_entry1, value))`
`527`	`527`	`{`
`528`	`528`	`RemoveAt(1);`
`529`	`529`	`return true;`
`530`	`530`	`}`
`531`		`- else if ((3 == _count) && (_entry2.Equals(value)))`
	`531`	`+ else if ((3 == _count) && EqualityComparer<T>.Default.Equals(_entry2, value))`
`532`	`532`	`{`
`533`	`533`	`RemoveAt(2);`
`534`	`534`	`return true;`
`@@ -781,35 +781,35 @@ public override bool Contains(T value)`
`781`	`781`
`782`	`782`	`public override int IndexOf(T value)`
`783`	`783`	`{`
`784`		`- if (_entry0.Equals(value))`
	`784`	`+ if (EqualityComparer<T>.Default.Equals(_entry0, value))`
`785`	`785`	`{`
`786`	`786`	`return 0;`
`787`	`787`	`}`
`788`	`788`	`if (_count > 1)`
`789`	`789`	`{`
`790`		`- if (_entry1.Equals(value))`
	`790`	`+ if (EqualityComparer<T>.Default.Equals(_entry1, value))`
`791`	`791`	`{`
`792`	`792`	`return 1;`
`793`	`793`	`}`
`794`	`794`	`if (_count > 2)`
`795`	`795`	`{`
`796`		`- if (_entry2.Equals(value))`
	`796`	`+ if (EqualityComparer<T>.Default.Equals(_entry2, value))`
`797`	`797`	`{`
`798`	`798`	`return 2;`
`799`	`799`	`}`
`800`	`800`	`if (_count > 3)`
`801`	`801`	`{`
`802`		`- if (_entry3.Equals(value))`
	`802`	`+ if (EqualityComparer<T>.Default.Equals(_entry3, value))`
`803`	`803`	`{`
`804`	`804`	`return 3;`
`805`	`805`	`}`
`806`	`806`	`if (_count > 4)`
`807`	`807`	`{`
`808`		`- if (_entry4.Equals(value))`
	`808`	`+ if (EqualityComparer<T>.Default.Equals(_entry4, value))`
`809`	`809`	`{`
`810`	`810`	`return 4;`
`811`	`811`	`}`
`812`		`- if ((6 == _count) && (_entry5.Equals(value)))`
	`812`	`+ if ((6 == _count) && EqualityComparer<T>.Default.Equals(_entry5, value))`
`813`	`813`	`{`
`814`	`814`	`return 5;`
`815`	`815`	`}`
`@@ -914,40 +914,40 @@ public override bool Remove(T value)`
`914`	`914`	`// If the item matches an existing entry, wipe out the last`
`915`	`915`	`// entry and move all the other entries up. Because we only`
`916`	`916`	`// have six entries we can just unravel all the cases.`
`917`		`- if (_entry0.Equals(value))`
	`917`	`+ if (EqualityComparer<T>.Default.Equals(_entry0, value))`
`918`	`918`	`{`
`919`	`919`	`RemoveAt(0);`
`920`	`920`	`return true;`
`921`	`921`	`}`
`922`	`922`	`else if (_count > 1)`
`923`	`923`	`{`
`924`		`- if (_entry1.Equals(value))`
	`924`	`+ if (EqualityComparer<T>.Default.Equals(_entry1, value))`
`925`	`925`	`{`
`926`	`926`	`RemoveAt(1);`
`927`	`927`	`return true;`
`928`	`928`	`}`
`929`	`929`	`else if (_count > 2)`
`930`	`930`	`{`
`931`		`- if (_entry2.Equals(value))`
	`931`	`+ if (EqualityComparer<T>.Default.Equals(_entry2, value))`
`932`	`932`	`{`
`933`	`933`	`RemoveAt(2);`
`934`	`934`	`return true;`
`935`	`935`	`}`
`936`	`936`	`else if (_count > 3)`
`937`	`937`	`{`
`938`		`- if (_entry3.Equals(value))`
	`938`	`+ if (EqualityComparer<T>.Default.Equals(_entry3, value))`
`939`	`939`	`{`
`940`	`940`	`RemoveAt(3);`
`941`	`941`	`return true;`
`942`	`942`	`}`
`943`	`943`	`else if (_count > 4)`
`944`	`944`	`{`
`945`		`- if (_entry4.Equals(value))`
	`945`	`+ if (EqualityComparer<T>.Default.Equals(_entry4, value))`
`946`	`946`	`{`
`947`	`947`	`RemoveAt(4);`
`948`	`948`	`return true;`
`949`	`949`	`}`
`950`		`- else if ((6 == _count) && (_entry5.Equals(value)))`
	`950`	`+ else if ((6 == _count) && EqualityComparer<T>.Default.Equals(_entry5, value))`
`951`	`951`	`{`
`952`	`952`	`RemoveAt(5);`
`953`	`953`	`return true;`
`@@ -1392,7 +1392,7 @@ public override int IndexOf(T value)`
`1392`	`1392`	`{`
`1393`	`1393`	`for (int index = 0; index < _count; ++index)`
`1394`	`1394`	`{`
`1395`		`- if (_entries[index].Equals(value))`
	`1395`	`+ if (EqualityComparer<T>.Default.Equals(_entries[index], value))`
`1396`	`1396`	`{`
`1397`	`1397`	`return index;`
`1398`	`1398`	`}`
`@@ -1425,7 +1425,7 @@ public override bool Remove(T value)`
`1425`	`1425`	`{`
`1426`	`1426`	`for (int index = 0; index < _count; ++index)`
`1427`	`1427`	`{`
`1428`		`- if (_entries[index].Equals(value))`
	`1428`	`+ if (EqualityComparer<T>.Default.Equals(_entries[index], value))`
`1429`	`1429`	`{`
`1430`	`1430`	`RemoveAt(index);`
`1431`	`1431`	`return true;`