Use MemberNotNullAttribute in ImmutableArray (dotnet#119898)

xtqqczze · web-flow · commit 843b197d1b3a · 2025-09-20T11:17:42.000-04:00
diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableArray_1.Minimal.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableArray_1.Minimal.cs
@@ -227,7 +227,7 @@ public void CopyTo(T[] destination)
         {
             ImmutableArray<T> self = this;
             self.ThrowNullRefIfNotInitialized();
-            Array.Copy(self.array!, destination, self.Length);
+            Array.Copy(self.array, destination, self.Length);
         }
 
         /// <summary>
@@ -239,7 +239,7 @@ public void CopyTo(T[] destination, int destinationIndex)
         {
             ImmutableArray<T> self = this;
             self.ThrowNullRefIfNotInitialized();
-            Array.Copy(self.array!, 0, destination, destinationIndex, self.Length);
+            Array.Copy(self.array, 0, destination, destinationIndex, self.Length);
         }
 
         /// <summary>
@@ -253,7 +253,7 @@ public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int l
         {
             ImmutableArray<T> self = this;
             self.ThrowNullRefIfNotInitialized();
-            Array.Copy(self.array!, sourceIndex, destination, destinationIndex, length);
+            Array.Copy(self.array, sourceIndex, destination, destinationIndex, length);
         }
 
         /// <summary>
@@ -282,7 +282,7 @@ public Enumerator GetEnumerator()
         {
             ImmutableArray<T> self = this;
             self.ThrowNullRefIfNotInitialized();
-            return new Enumerator(self.array!);
+            return new Enumerator(self.array);
         }
 
         /// <summary>
@@ -388,7 +388,7 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()
         {
             ImmutableArray<T> self = this;
             self.ThrowInvalidOperationIfNotInitialized();
-            return EnumeratorObject.Create(self.array!);
+            return EnumeratorObject.Create(self.array);
         }
 
         /// <summary>
@@ -400,12 +400,13 @@ IEnumerator IEnumerable.GetEnumerator()
         {
             ImmutableArray<T> self = this;
             self.ThrowInvalidOperationIfNotInitialized();
-            return EnumeratorObject.Create(self.array!);
+            return EnumeratorObject.Create(self.array);
         }
 
         /// <summary>
         /// Throws a null reference exception if the array field is null.
         /// </summary>
+        [MemberNotNull(nameof(array))]
         internal void ThrowNullRefIfNotInitialized()
         {
             // Force NullReferenceException if array is null by touching its Length.
@@ -427,9 +428,10 @@ internal void ThrowNullRefIfNotInitialized()
         ///
         /// This is intended for explicitly implemented interface method and property implementations.
         /// </summary>
+        [MemberNotNull(nameof(array))]
         private void ThrowInvalidOperationIfNotInitialized()
         {
-            if (this.IsDefault)
+            if (this.array == null)
             {
                 throw new InvalidOperationException(SR.InvalidOperationOnDefaultArray);
             }
diff --git a/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableArray_1.cs b/src/libraries/System.Collections.Immutable/src/System/Collections/Immutable/ImmutableArray_1.cs
@@ -179,13 +179,13 @@ public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equa
             equalityComparer ??= EqualityComparer<T>.Default;
             if (equalityComparer == EqualityComparer<T>.Default)
             {
-                return Array.IndexOf(self.array!, item, startIndex, count);
+                return Array.IndexOf(self.array, item, startIndex, count);
             }
             else
             {
                 for (int i = startIndex; i < startIndex + count; i++)
                 {
-                    if (equalityComparer.Equals(self.array![i], item))
+                    if (equalityComparer.Equals(self.array[i], item))
                     {
                         return i;
                     }
@@ -264,13 +264,13 @@ public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T>?
             equalityComparer ??= EqualityComparer<T>.Default;
             if (equalityComparer == EqualityComparer<T>.Default)
             {
-                return Array.LastIndexOf(self.array!, item, startIndex, count);
+                return Array.LastIndexOf(self.array, item, startIndex, count);
             }
             else
             {
                 for (int i = startIndex; i >= startIndex - count + 1; i--)
                 {
-                    if (equalityComparer.Equals(item, self.array![i]))
+                    if (equalityComparer.Equals(item, self.array[i]))
                     {
                         return i;
                     }
@@ -326,11 +326,11 @@ public ImmutableArray<T> Insert(int index, T item)
 
             if (index != 0)
             {
-                Array.Copy(self.array!, tmp, index);
+                Array.Copy(self.array, tmp, index);
             }
             if (index != self.Length)
             {
-                Array.Copy(self.array!, index, tmp, index + 1, self.Length - index);
+                Array.Copy(self.array, index, tmp, index + 1, self.Length - index);
             }
 
             return new ImmutableArray<T>(tmp);
@@ -364,11 +364,11 @@ public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items)
 
             if (index != 0)
             {
-                Array.Copy(self.array!, tmp, index);
+                Array.Copy(self.array, tmp, index);
             }
             if (index != self.Length)
             {
-                Array.Copy(self.array!, index, tmp, index + count, self.Length - index);
+                Array.Copy(self.array, index, tmp, index + count, self.Length - index);
             }
 
             // We want to copy over the items we need to insert.
@@ -464,7 +464,7 @@ public ImmutableArray<T> AddRange(T[] items, int length)
             }
 
             T[] tmp = new T[self.Length + length];
-            Array.Copy(self.array!, tmp, self.Length);
+            Array.Copy(self.array, tmp, self.Length);
             Array.Copy(items, 0, tmp, self.Length, length);
 
             return new ImmutableArray<T>(tmp);
@@ -488,7 +488,7 @@ public ImmutableArray<T> AddRange<TDerived>(TDerived[] items) where TDerived : T
             }
 
             T[] tmp = new T[self.Length + items.Length];
-            Array.Copy(self.array!, tmp, self.Length);
+            Array.Copy(self.array, tmp, self.Length);
             Array.Copy(items, 0, tmp, self.Length, items.Length);
 
             return new ImmutableArray<T>(tmp);
@@ -558,7 +558,7 @@ public ImmutableArray<T> SetItem(int index, T item)
             Requires.Range(index >= 0 && index < self.Length, nameof(index));
 
             T[] tmp = new T[self.Length];
-            Array.Copy(self.array!, tmp, self.Length);
+            Array.Copy(self.array, tmp, self.Length);
             tmp[index] = item;
             return new ImmutableArray<T>(tmp);
         }
@@ -658,8 +658,8 @@ public ImmutableArray<T> RemoveRange(int index, int length)
             }
 
             T[] tmp = new T[self.Length - length];
-            Array.Copy(self.array!, tmp, index);
-            Array.Copy(self.array!, index + length, tmp, index, self.Length - index - length);
+            Array.Copy(self.array, tmp, index);
+            Array.Copy(self.array, index + length, tmp, index, self.Length - index - length);
             return new ImmutableArray<T>(tmp);
         }
 
@@ -757,7 +757,7 @@ public ImmutableArray<T> RemoveAll(Predicate<T> match)
             }
 
             List<int>? removeIndices = null;
-            for (int i = 0; i < self.array!.Length; i++)
+            for (int i = 0; i < self.array.Length; i++)
             {
                 if (match(self.array[i]))
                 {
@@ -838,7 +838,7 @@ public ImmutableArray<T> Sort(int index, int count, IComparer<T>? comparer)
                 bool outOfOrder = false;
                 for (int i = index + 1; i < index + count; i++)
                 {
-                    if (comparer.Compare(self.array![i - 1], self.array[i]) > 0)
+                    if (comparer.Compare(self.array[i - 1], self.array[i]) > 0)
                     {
                         outOfOrder = true;
                         break;
@@ -848,7 +848,7 @@ public ImmutableArray<T> Sort(int index, int count, IComparer<T>? comparer)
                 if (outOfOrder)
                 {
                     var tmp = new T[self.Length];
-                    Array.Copy(self.array!, tmp, self.Length);
+                    Array.Copy(self.array, tmp, self.Length);
                     Array.Sort(tmp, index, count, comparer);
                     return new ImmutableArray<T>(tmp);
                 }
@@ -1372,7 +1372,7 @@ void ICollection.CopyTo(Array array, int index)
         {
             ImmutableArray<T> self = this;
             self.ThrowInvalidOperationIfNotInitialized();
-            Array.Copy(self.array!, 0, array, index, self.Length);
+            Array.Copy(self.array, 0, array, index, self.Length);
         }
 
         /// <summary>
@@ -1494,13 +1494,13 @@ private ImmutableArray<T> RemoveAtRange(ICollection<int> indicesToRemove)
             {
                 int copyLength = lastIndexRemoved == -1 ? indexToRemove : (indexToRemove - lastIndexRemoved - 1);
                 Debug.Assert(indexToRemove > lastIndexRemoved); // We require that the input be a sorted set.
-                Array.Copy(self.array!, copied + removed, newArray, copied, copyLength);
+                Array.Copy(self.array, copied + removed, newArray, copied, copyLength);
                 removed++;
                 copied += copyLength;
                 lastIndexRemoved = indexToRemove;
             }
 
-            Array.Copy(self.array!, copied + removed, newArray, copied, self.Length - (copied + removed));
+            Array.Copy(self.array, copied + removed, newArray, copied, self.Length - (copied + removed));
 
             return new ImmutableArray<T>(newArray);
         }
diff --git a/src/libraries/System.Collections.Immutable/src/System/Linq/ImmutableArrayExtensions.cs b/src/libraries/System.Collections.Immutable/src/System/Linq/ImmutableArrayExtensions.cs
@@ -28,7 +28,7 @@ public static IEnumerable<TResult> Select<T, TResult>(this ImmutableArray<T> imm
             // LINQ Select/Where have optimized treatment for arrays.
             // They also do not modify the source arrays or expose them to modifications.
             // Therefore we will just apply Select/Where to the underlying this.array array.
-            return immutableArray.array!.Select(selector);
+            return immutableArray.array.Select(selector);
         }
 
         /// <summary>
@@ -86,7 +86,7 @@ public static IEnumerable<T> Where<T>(this ImmutableArray<T> immutableArray, Fun
             // LINQ Select/Where have optimized treatment for arrays.
             // They also do not modify the source arrays or expose them to modifications.
             // Therefore we will just apply Select/Where to the underlying this.array array.
-            return immutableArray.array!.Where(predicate);
+            return immutableArray.array.Where(predicate);
         }
 
         /// <summary>
@@ -111,7 +111,7 @@ public static bool Any<T>(this ImmutableArray<T> immutableArray, Func<T, bool> p
             immutableArray.ThrowNullRefIfNotInitialized();
             Requires.NotNull(predicate, nameof(predicate));
 
-            foreach (T v in immutableArray.array!)
+            foreach (T v in immutableArray.array)
             {
                 if (predicate(v))
                 {
@@ -137,7 +137,7 @@ public static bool All<T>(this ImmutableArray<T> immutableArray, Func<T, bool> p
             immutableArray.ThrowNullRefIfNotInitialized();
             Requires.NotNull(predicate, nameof(predicate));
 
-            foreach (T v in immutableArray.array!)
+            foreach (T v in immutableArray.array)
             {
                 if (!predicate(v))
                 {
@@ -171,7 +171,7 @@ public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> imm
 
             for (int i = 0; i < immutableArray.Length; i++)
             {
-                if (!comparer.Equals(immutableArray.array![i], items.array![i]))
+                if (!comparer.Equals(immutableArray.array[i], items.array[i]))
                 {
                     return false;
                 }
@@ -429,7 +429,7 @@ public static T Last<T>(this ImmutableArray<T> immutableArray, Func<T, bool> pre
         public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray)
         {
             immutableArray.ThrowNullRefIfNotInitialized();
-            return immutableArray.array!.LastOrDefault()!;
+            return immutableArray.array.LastOrDefault()!;
         }
 
         /// <summary>
@@ -459,7 +459,7 @@ public static T Last<T>(this ImmutableArray<T> immutableArray, Func<T, bool> pre
         public static T Single<T>(this ImmutableArray<T> immutableArray)
         {
             immutableArray.ThrowNullRefIfNotInitialized();
-            return immutableArray.array!.Single();
+            return immutableArray.array.Single();
         }
 
         /// <summary>
@@ -504,7 +504,7 @@ public static T Single<T>(this ImmutableArray<T> immutableArray, Func<T, bool> p
         public static T? SingleOrDefault<T>(this ImmutableArray<T> immutableArray)
         {
             immutableArray.ThrowNullRefIfNotInitialized();
-            return immutableArray.array!.SingleOrDefault()!;
+            return immutableArray.array.SingleOrDefault()!;
         }
 
         /// <summary>
@@ -618,7 +618,7 @@ public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, T>(this Im
         public static T[] ToArray<T>(this ImmutableArray<T> immutableArray)
         {
             immutableArray.ThrowNullRefIfNotInitialized();
-            if (immutableArray.array!.Length == 0)
+            if (immutableArray.array.Length == 0)
             {
                 return ImmutableArray<T>.Empty.array!;
             }

Original file line number	Diff line number	Diff line change
`@@ -227,7 +227,7 @@ public void CopyTo(T[] destination)`
`227`	`227`	`{`
`228`	`228`	`ImmutableArray<T> self = this;`
`229`	`229`	`self.ThrowNullRefIfNotInitialized();`
`230`		`- Array.Copy(self.array!, destination, self.Length);`
	`230`	`+ Array.Copy(self.array, destination, self.Length);`
`231`	`231`	`}`
`232`	`232`
`233`	`233`	`/// <summary>`
`@@ -239,7 +239,7 @@ public void CopyTo(T[] destination, int destinationIndex)`
`239`	`239`	`{`
`240`	`240`	`ImmutableArray<T> self = this;`
`241`	`241`	`self.ThrowNullRefIfNotInitialized();`
`242`		`- Array.Copy(self.array!, 0, destination, destinationIndex, self.Length);`
	`242`	`+ Array.Copy(self.array, 0, destination, destinationIndex, self.Length);`
`243`	`243`	`}`
`244`	`244`
`245`	`245`	`/// <summary>`
`@@ -253,7 +253,7 @@ public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int l`
`253`	`253`	`{`
`254`	`254`	`ImmutableArray<T> self = this;`
`255`	`255`	`self.ThrowNullRefIfNotInitialized();`
`256`		`- Array.Copy(self.array!, sourceIndex, destination, destinationIndex, length);`
	`256`	`+ Array.Copy(self.array, sourceIndex, destination, destinationIndex, length);`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`/// <summary>`
`@@ -282,7 +282,7 @@ public Enumerator GetEnumerator()`
`282`	`282`	`{`
`283`	`283`	`ImmutableArray<T> self = this;`
`284`	`284`	`self.ThrowNullRefIfNotInitialized();`
`285`		`- return new Enumerator(self.array!);`
	`285`	`+ return new Enumerator(self.array);`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`/// <summary>`
`@@ -388,7 +388,7 @@ IEnumerator<T> IEnumerable<T>.GetEnumerator()`
`388`	`388`	`{`
`389`	`389`	`ImmutableArray<T> self = this;`
`390`	`390`	`self.ThrowInvalidOperationIfNotInitialized();`
`391`		`- return EnumeratorObject.Create(self.array!);`
	`391`	`+ return EnumeratorObject.Create(self.array);`
`392`	`392`	`}`
`393`	`393`
`394`	`394`	`/// <summary>`
`@@ -400,12 +400,13 @@ IEnumerator IEnumerable.GetEnumerator()`
`400`	`400`	`{`
`401`	`401`	`ImmutableArray<T> self = this;`
`402`	`402`	`self.ThrowInvalidOperationIfNotInitialized();`
`403`		`- return EnumeratorObject.Create(self.array!);`
	`403`	`+ return EnumeratorObject.Create(self.array);`
`404`	`404`	`}`
`405`	`405`
`406`	`406`	`/// <summary>`
`407`	`407`	`/// Throws a null reference exception if the array field is null.`
`408`	`408`	`/// </summary>`
	`409`	`+ [MemberNotNull(nameof(array))]`
`409`	`410`	`internal void ThrowNullRefIfNotInitialized()`
`410`	`411`	`{`
`411`	`412`	`// Force NullReferenceException if array is null by touching its Length.`
`@@ -427,9 +428,10 @@ internal void ThrowNullRefIfNotInitialized()`
`427`	`428`	`///`
`428`	`429`	`/// This is intended for explicitly implemented interface method and property implementations.`
`429`	`430`	`/// </summary>`
	`431`	`+ [MemberNotNull(nameof(array))]`
`430`	`432`	`private void ThrowInvalidOperationIfNotInitialized()`
`431`	`433`	`{`
`432`		`- if (this.IsDefault)`
	`434`	`+ if (this.array == null)`
`433`	`435`	`{`
`434`	`436`	`throw new InvalidOperationException(SR.InvalidOperationOnDefaultArray);`
`435`	`437`	`}`
Original file line number	Diff line number	Diff line change
`@@ -179,13 +179,13 @@ public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T>? equa`
`179`	`179`	`equalityComparer ??= EqualityComparer<T>.Default;`
`180`	`180`	`if (equalityComparer == EqualityComparer<T>.Default)`
`181`	`181`	`{`
`182`		`- return Array.IndexOf(self.array!, item, startIndex, count);`
	`182`	`+ return Array.IndexOf(self.array, item, startIndex, count);`
`183`	`183`	`}`
`184`	`184`	`else`
`185`	`185`	`{`
`186`	`186`	`for (int i = startIndex; i < startIndex + count; i++)`
`187`	`187`	`{`
`188`		`- if (equalityComparer.Equals(self.array![i], item))`
	`188`	`+ if (equalityComparer.Equals(self.array[i], item))`
`189`	`189`	`{`
`190`	`190`	`return i;`
`191`	`191`	`}`
`@@ -264,13 +264,13 @@ public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T>?`
`264`	`264`	`equalityComparer ??= EqualityComparer<T>.Default;`
`265`	`265`	`if (equalityComparer == EqualityComparer<T>.Default)`
`266`	`266`	`{`
`267`		`- return Array.LastIndexOf(self.array!, item, startIndex, count);`
	`267`	`+ return Array.LastIndexOf(self.array, item, startIndex, count);`
`268`	`268`	`}`
`269`	`269`	`else`
`270`	`270`	`{`
`271`	`271`	`for (int i = startIndex; i >= startIndex - count + 1; i--)`
`272`	`272`	`{`
`273`		`- if (equalityComparer.Equals(item, self.array![i]))`
	`273`	`+ if (equalityComparer.Equals(item, self.array[i]))`
`274`	`274`	`{`
`275`	`275`	`return i;`
`276`	`276`	`}`
`@@ -326,11 +326,11 @@ public ImmutableArray<T> Insert(int index, T item)`
`326`	`326`
`327`	`327`	`if (index != 0)`
`328`	`328`	`{`
`329`		`- Array.Copy(self.array!, tmp, index);`
	`329`	`+ Array.Copy(self.array, tmp, index);`
`330`	`330`	`}`
`331`	`331`	`if (index != self.Length)`
`332`	`332`	`{`
`333`		`- Array.Copy(self.array!, index, tmp, index + 1, self.Length - index);`
	`333`	`+ Array.Copy(self.array, index, tmp, index + 1, self.Length - index);`
`334`	`334`	`}`
`335`	`335`
`336`	`336`	`return new ImmutableArray<T>(tmp);`
`@@ -364,11 +364,11 @@ public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items)`
`364`	`364`
`365`	`365`	`if (index != 0)`
`366`	`366`	`{`
`367`		`- Array.Copy(self.array!, tmp, index);`
	`367`	`+ Array.Copy(self.array, tmp, index);`
`368`	`368`	`}`
`369`	`369`	`if (index != self.Length)`
`370`	`370`	`{`
`371`		`- Array.Copy(self.array!, index, tmp, index + count, self.Length - index);`
	`371`	`+ Array.Copy(self.array, index, tmp, index + count, self.Length - index);`
`372`	`372`	`}`
`373`	`373`
`374`	`374`	`// We want to copy over the items we need to insert.`
`@@ -464,7 +464,7 @@ public ImmutableArray<T> AddRange(T[] items, int length)`
`464`	`464`	`}`
`465`	`465`
`466`	`466`	`T[] tmp = new T[self.Length + length];`
`467`		`- Array.Copy(self.array!, tmp, self.Length);`
	`467`	`+ Array.Copy(self.array, tmp, self.Length);`
`468`	`468`	`Array.Copy(items, 0, tmp, self.Length, length);`
`469`	`469`
`470`	`470`	`return new ImmutableArray<T>(tmp);`
`@@ -488,7 +488,7 @@ public ImmutableArray<T> AddRange<TDerived>(TDerived[] items) where TDerived : T`
`488`	`488`	`}`
`489`	`489`
`490`	`490`	`T[] tmp = new T[self.Length + items.Length];`
`491`		`- Array.Copy(self.array!, tmp, self.Length);`
	`491`	`+ Array.Copy(self.array, tmp, self.Length);`
`492`	`492`	`Array.Copy(items, 0, tmp, self.Length, items.Length);`
`493`	`493`
`494`	`494`	`return new ImmutableArray<T>(tmp);`
`@@ -558,7 +558,7 @@ public ImmutableArray<T> SetItem(int index, T item)`
`558`	`558`	`Requires.Range(index >= 0 && index < self.Length, nameof(index));`
`559`	`559`
`560`	`560`	`T[] tmp = new T[self.Length];`
`561`		`- Array.Copy(self.array!, tmp, self.Length);`
	`561`	`+ Array.Copy(self.array, tmp, self.Length);`
`562`	`562`	`tmp[index] = item;`
`563`	`563`	`return new ImmutableArray<T>(tmp);`
`564`	`564`	`}`
`@@ -658,8 +658,8 @@ public ImmutableArray<T> RemoveRange(int index, int length)`
`658`	`658`	`}`
`659`	`659`
`660`	`660`	`T[] tmp = new T[self.Length - length];`
`661`		`- Array.Copy(self.array!, tmp, index);`
`662`		`- Array.Copy(self.array!, index + length, tmp, index, self.Length - index - length);`
	`661`	`+ Array.Copy(self.array, tmp, index);`
	`662`	`+ Array.Copy(self.array, index + length, tmp, index, self.Length - index - length);`
`663`	`663`	`return new ImmutableArray<T>(tmp);`
`664`	`664`	`}`
`665`	`665`
`@@ -757,7 +757,7 @@ public ImmutableArray<T> RemoveAll(Predicate<T> match)`
`757`	`757`	`}`
`758`	`758`
`759`	`759`	`List<int>? removeIndices = null;`
`760`		`- for (int i = 0; i < self.array!.Length; i++)`
	`760`	`+ for (int i = 0; i < self.array.Length; i++)`
`761`	`761`	`{`
`762`	`762`	`if (match(self.array[i]))`
`763`	`763`	`{`
`@@ -838,7 +838,7 @@ public ImmutableArray<T> Sort(int index, int count, IComparer<T>? comparer)`
`838`	`838`	`bool outOfOrder = false;`
`839`	`839`	`for (int i = index + 1; i < index + count; i++)`
`840`	`840`	`{`
`841`		`- if (comparer.Compare(self.array![i - 1], self.array[i]) > 0)`
	`841`	`+ if (comparer.Compare(self.array[i - 1], self.array[i]) > 0)`
`842`	`842`	`{`
`843`	`843`	`outOfOrder = true;`
`844`	`844`	`break;`
`@@ -848,7 +848,7 @@ public ImmutableArray<T> Sort(int index, int count, IComparer<T>? comparer)`
`848`	`848`	`if (outOfOrder)`
`849`	`849`	`{`
`850`	`850`	`var tmp = new T[self.Length];`
`851`		`- Array.Copy(self.array!, tmp, self.Length);`
	`851`	`+ Array.Copy(self.array, tmp, self.Length);`
`852`	`852`	`Array.Sort(tmp, index, count, comparer);`
`853`	`853`	`return new ImmutableArray<T>(tmp);`
`854`	`854`	`}`
`@@ -1372,7 +1372,7 @@ void ICollection.CopyTo(Array array, int index)`
`1372`	`1372`	`{`
`1373`	`1373`	`ImmutableArray<T> self = this;`
`1374`	`1374`	`self.ThrowInvalidOperationIfNotInitialized();`
`1375`		`- Array.Copy(self.array!, 0, array, index, self.Length);`
	`1375`	`+ Array.Copy(self.array, 0, array, index, self.Length);`
`1376`	`1376`	`}`
`1377`	`1377`
`1378`	`1378`	`/// <summary>`
`@@ -1494,13 +1494,13 @@ private ImmutableArray<T> RemoveAtRange(ICollection<int> indicesToRemove)`
`1494`	`1494`	`{`
`1495`	`1495`	`int copyLength = lastIndexRemoved == -1 ? indexToRemove : (indexToRemove - lastIndexRemoved - 1);`
`1496`	`1496`	`Debug.Assert(indexToRemove > lastIndexRemoved); // We require that the input be a sorted set.`
`1497`		`- Array.Copy(self.array!, copied + removed, newArray, copied, copyLength);`
	`1497`	`+ Array.Copy(self.array, copied + removed, newArray, copied, copyLength);`
`1498`	`1498`	`removed++;`
`1499`	`1499`	`copied += copyLength;`
`1500`	`1500`	`lastIndexRemoved = indexToRemove;`
`1501`	`1501`	`}`
`1502`	`1502`
`1503`		`- Array.Copy(self.array!, copied + removed, newArray, copied, self.Length - (copied + removed));`
	`1503`	`+ Array.Copy(self.array, copied + removed, newArray, copied, self.Length - (copied + removed));`
`1504`	`1504`
`1505`	`1505`	`return new ImmutableArray<T>(newArray);`
`1506`	`1506`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ public static IEnumerable<TResult> Select<T, TResult>(this ImmutableArray<T> imm`
`28`	`28`	`// LINQ Select/Where have optimized treatment for arrays.`
`29`	`29`	`// They also do not modify the source arrays or expose them to modifications.`
`30`	`30`	`// Therefore we will just apply Select/Where to the underlying this.array array.`
`31`		`- return immutableArray.array!.Select(selector);`
	`31`	`+ return immutableArray.array.Select(selector);`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`/// <summary>`
`@@ -86,7 +86,7 @@ public static IEnumerable<T> Where<T>(this ImmutableArray<T> immutableArray, Fun`
`86`	`86`	`// LINQ Select/Where have optimized treatment for arrays.`
`87`	`87`	`// They also do not modify the source arrays or expose them to modifications.`
`88`	`88`	`// Therefore we will just apply Select/Where to the underlying this.array array.`
`89`		`- return immutableArray.array!.Where(predicate);`
	`89`	`+ return immutableArray.array.Where(predicate);`
`90`	`90`	`}`
`91`	`91`
`92`	`92`	`/// <summary>`
`@@ -111,7 +111,7 @@ public static bool Any<T>(this ImmutableArray<T> immutableArray, Func<T, bool> p`
`111`	`111`	`immutableArray.ThrowNullRefIfNotInitialized();`
`112`	`112`	`Requires.NotNull(predicate, nameof(predicate));`
`113`	`113`
`114`		`- foreach (T v in immutableArray.array!)`
	`114`	`+ foreach (T v in immutableArray.array)`
`115`	`115`	`{`
`116`	`116`	`if (predicate(v))`
`117`	`117`	`{`
`@@ -137,7 +137,7 @@ public static bool All<T>(this ImmutableArray<T> immutableArray, Func<T, bool> p`
`137`	`137`	`immutableArray.ThrowNullRefIfNotInitialized();`
`138`	`138`	`Requires.NotNull(predicate, nameof(predicate));`
`139`	`139`
`140`		`- foreach (T v in immutableArray.array!)`
	`140`	`+ foreach (T v in immutableArray.array)`
`141`	`141`	`{`
`142`	`142`	`if (!predicate(v))`
`143`	`143`	`{`
`@@ -171,7 +171,7 @@ public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> imm`
`171`	`171`
`172`	`172`	`for (int i = 0; i < immutableArray.Length; i++)`
`173`	`173`	`{`
`174`		`- if (!comparer.Equals(immutableArray.array![i], items.array![i]))`
	`174`	`+ if (!comparer.Equals(immutableArray.array[i], items.array[i]))`
`175`	`175`	`{`
`176`	`176`	`return false;`
`177`	`177`	`}`
`@@ -429,7 +429,7 @@ public static T Last<T>(this ImmutableArray<T> immutableArray, Func<T, bool> pre`
`429`	`429`	`public static T? LastOrDefault<T>(this ImmutableArray<T> immutableArray)`
`430`	`430`	`{`
`431`	`431`	`immutableArray.ThrowNullRefIfNotInitialized();`
`432`		`- return immutableArray.array!.LastOrDefault()!;`
	`432`	`+ return immutableArray.array.LastOrDefault()!;`
`433`	`433`	`}`
`434`	`434`
`435`	`435`	`/// <summary>`
`@@ -459,7 +459,7 @@ public static T Last<T>(this ImmutableArray<T> immutableArray, Func<T, bool> pre`
`459`	`459`	`public static T Single<T>(this ImmutableArray<T> immutableArray)`
`460`	`460`	`{`
`461`	`461`	`immutableArray.ThrowNullRefIfNotInitialized();`
`462`		`- return immutableArray.array!.Single();`
	`462`	`+ return immutableArray.array.Single();`
`463`	`463`	`}`
`464`	`464`
`465`	`465`	`/// <summary>`
`@@ -504,7 +504,7 @@ public static T Single<T>(this ImmutableArray<T> immutableArray, Func<T, bool> p`
`504`	`504`	`public static T? SingleOrDefault<T>(this ImmutableArray<T> immutableArray)`
`505`	`505`	`{`
`506`	`506`	`immutableArray.ThrowNullRefIfNotInitialized();`
`507`		`- return immutableArray.array!.SingleOrDefault()!;`
	`507`	`+ return immutableArray.array.SingleOrDefault()!;`
`508`	`508`	`}`
`509`	`509`
`510`	`510`	`/// <summary>`
`@@ -618,7 +618,7 @@ public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, T>(this Im`
`618`	`618`	`public static T[] ToArray<T>(this ImmutableArray<T> immutableArray)`
`619`	`619`	`{`
`620`	`620`	`immutableArray.ThrowNullRefIfNotInitialized();`
`621`		`- if (immutableArray.array!.Length == 0)`
	`621`	`+ if (immutableArray.array.Length == 0)`
`622`	`622`	`{`
`623`	`623`	`return ImmutableArray<T>.Empty.array!;`
`624`	`624`	`}`