Tweaks to ValueComparer nullability (#24410)

roji · web-flow · commit 8ee0305df051 · 2021-08-20T19:36:42.000+02:00
* Make Snapshot accept/receive non-nullable (nulls are sanitized
  externally).
* Make ValueComparer&lt;T&gt;.GetHashCode accept non-nullable object.
diff --git a/src/EFCore.Cosmos/ChangeTracking/Internal/ListComparer.cs b/src/EFCore.Cosmos/ChangeTracking/Internal/ListComparer.cs
@@ -77,13 +77,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme
             return hash.ToHashCode();
         }
 
-        private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)
+        private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)
         {
-            if (source is null)
-            {
-                return null;
-            }
-
             if (readOnly)
             {
                 return source;
@@ -92,7 +87,7 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme
             var snapshot = new List<TElement>(((IReadOnlyList<TElement>)source).Count);
             foreach (var e in source)
             {
-                snapshot.Add(elementComparer.Snapshot(e)!);
+                snapshot.Add(e is null ? default! : elementComparer.Snapshot(e));
             }
 
             return (TCollection)(object)snapshot;
diff --git a/src/EFCore.Cosmos/ChangeTracking/Internal/NullableListComparer.cs b/src/EFCore.Cosmos/ChangeTracking/Internal/NullableListComparer.cs
@@ -89,13 +89,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme
             return hash.ToHashCode();
         }
 
-        private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)
+        private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)
         {
-            if (source is null)
-            {
-                return null;
-            }
-
             if (readOnly)
             {
                 return source;
diff --git a/src/EFCore.Cosmos/ChangeTracking/Internal/NullableSingleDimensionalArrayComparer.cs b/src/EFCore.Cosmos/ChangeTracking/Internal/NullableSingleDimensionalArrayComparer.cs
@@ -88,13 +88,8 @@ private static int GetHashCode(TElement?[] source, ValueComparer<TElement> eleme
         }
 
         [return: NotNullIfNotNull("source")]
-        private static TElement?[]? Snapshot(TElement?[]? source, ValueComparer<TElement> elementComparer)
+        private static TElement?[] Snapshot(TElement?[] source, ValueComparer<TElement> elementComparer)
         {
-            if (source is null)
-            {
-                return null;
-            }
-
             var snapshot = new TElement?[source.Length];
             for (var i = 0; i < source.Length; i++)
             {
diff --git a/src/EFCore.Cosmos/ChangeTracking/Internal/NullableStringDictionaryComparer.cs b/src/EFCore.Cosmos/ChangeTracking/Internal/NullableStringDictionaryComparer.cs
@@ -95,13 +95,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme
             return hash.ToHashCode();
         }
 
-        private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)
+        private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)
         {
-            if (source is null)
-            {
-                return null;
-            }
-
             if (readOnly)
             {
                 return source;
diff --git a/src/EFCore.Cosmos/ChangeTracking/Internal/SingleDimensionalArrayComparer.cs b/src/EFCore.Cosmos/ChangeTracking/Internal/SingleDimensionalArrayComparer.cs
@@ -76,17 +76,13 @@ private static int GetHashCode(TElement[] source, ValueComparer<TElement> elemen
         }
 
         [return: NotNullIfNotNull("source")]
-        private static TElement[]? Snapshot(TElement[]? source, ValueComparer<TElement> elementComparer)
+        private static TElement[] Snapshot(TElement[] source, ValueComparer<TElement> elementComparer)
         {
-            if (source is null)
-            {
-                return null;
-            }
-
             var snapshot = new TElement[source.Length];
             for (var i = 0; i < source.Length; i++)
             {
-                snapshot[i] = elementComparer.Snapshot(source[i])!;
+                var element = source[i];
+                snapshot[i] = element is null ? default! : elementComparer.Snapshot(source[i]);
             }
             return snapshot;
         }
diff --git a/src/EFCore.Cosmos/ChangeTracking/Internal/StringDictionaryComparer.cs b/src/EFCore.Cosmos/ChangeTracking/Internal/StringDictionaryComparer.cs
@@ -79,13 +79,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme
             return hash.ToHashCode();
         }
 
-        private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)
+        private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)
         {
-            if (source is null)
-            {
-                return null;
-            }
-
             if (readOnly)
             {
                 return source;
@@ -94,7 +89,7 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme
             var snapshot = new Dictionary<string, TElement>(((IReadOnlyDictionary<string, TElement>)source).Count);
             foreach (var e in source)
             {
-                snapshot.Add(e.Key, elementComparer.Snapshot(e.Value)!);
+                snapshot.Add(e.Key, e.Value is null ? default! : elementComparer.Snapshot(e.Value));
             }
 
             return (TCollection)(object)snapshot;
diff --git a/src/EFCore.SqlServer/Storage/Internal/SqlServerTypeMappingSource.cs b/src/EFCore.SqlServer/Storage/Internal/SqlServerTypeMappingSource.cs
@@ -52,7 +52,7 @@ private readonly SqlServerByteArrayTypeMapping _rowversion
                 comparer: new ValueComparer<byte[]>(
                     (v1, v2) => StructuralComparisons.StructuralEqualityComparer.Equals(v1, v2),
                     v => StructuralComparisons.StructuralEqualityComparer.GetHashCode(v),
-                    v => v == null ? null : v.ToArray()),
+                    v => v.ToArray()),
                 storeTypePostfix: StoreTypePostfix.None);
 
         private readonly IntTypeMapping _int
diff --git a/src/EFCore/ChangeTracking/ArrayStructuralComparer.cs b/src/EFCore/ChangeTracking/ArrayStructuralComparer.cs
@@ -24,7 +24,7 @@ public ArrayStructuralComparer()
             : base(
                 CreateDefaultEqualsExpression(),
                 CreateDefaultHashCodeExpression(favorStructuralComparisons: true),
-                v => v == null ? null : v.ToArray())
+                v => v.ToArray())
         {
         }
     }
diff --git a/src/EFCore/ChangeTracking/GeometryValueComparer.cs b/src/EFCore/ChangeTracking/GeometryValueComparer.cs
@@ -58,7 +58,7 @@ public GeometryValueComparer()
                 right);
         }
 
-        private static Expression<Func<TGeometry?, TGeometry?>> GetSnapshotExpression()
+        private static Expression<Func<TGeometry, TGeometry>> GetSnapshotExpression()
         {
             var instance = Expression.Parameter(typeof(TGeometry), "instance");
 
@@ -71,7 +71,7 @@ public GeometryValueComparer()
                 body = Expression.Convert(body, typeof(TGeometry));
             }
 
-            return Expression.Lambda<Func<TGeometry?, TGeometry?>>(body, instance);
+            return Expression.Lambda<Func<TGeometry, TGeometry>>(body, instance);
         }
     }
 }
diff --git a/src/EFCore/ChangeTracking/Internal/SimplePrincipalKeyValueFactory.cs b/src/EFCore/ChangeTracking/Internal/SimplePrincipalKeyValueFactory.cs
@@ -148,7 +148,7 @@ public NoNullsCustomEqualityComparer(ValueComparer comparer)
             public bool Equals(TKey? x, TKey? y)
                 => _equals(x, y);
 
-            public int GetHashCode(TKey obj)
+            public int GetHashCode([DisallowNull] TKey obj)
                 => _hashCode(obj);
         }
     }
diff --git a/src/EFCore/ChangeTracking/Internal/ValueComparerExtensions.cs b/src/EFCore/ChangeTracking/Internal/ValueComparerExtensions.cs
@@ -58,7 +58,7 @@ public NonNullNullableValueComparer(
                 : base(
                     (Expression<Func<T?, T?, bool>>)equalsExpression,
                     (Expression<Func<T, int>>)hashCodeExpression,
-                    (Expression<Func<T?, T?>>)snapshotExpression)
+                    (Expression<Func<T, T>>)snapshotExpression)
             {
             }
         }
diff --git a/src/EFCore/ChangeTracking/ValueComparer.cs b/src/EFCore/ChangeTracking/ValueComparer.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
@@ -106,6 +107,7 @@ protected ValueComparer(
         /// </summary>
         /// <param name="instance"> The instance. </param>
         /// <returns> The snapshot. </returns>
+        [return: NotNullIfNotNull("instance")]
         public abstract object? Snapshot(object? instance);
 
         /// <summary>
@@ -196,31 +198,31 @@ public virtual Expression ExtractSnapshotBody(Expression expression)
         /// <returns> The <see cref="ValueComparer{T}" />. </returns>
         public static ValueComparer CreateDefault(Type type, bool favorStructuralComparisons)
         {
-            var nonNullabletype = type.UnwrapNullableType();
+            var nonNullableType = type.UnwrapNullableType();
 
             // The equality operator returns false for NaNs, but the Equals methods returns true
-            if (nonNullabletype == typeof(double))
+            if (nonNullableType == typeof(double))
             {
                 return new DefaultDoubleValueComparer(favorStructuralComparisons);
             }
 
-            if (nonNullabletype == typeof(float))
+            if (nonNullableType == typeof(float))
             {
                 return new DefaultFloatValueComparer(favorStructuralComparisons);
             }
 
-            if (nonNullabletype == typeof(DateTimeOffset))
+            if (nonNullableType == typeof(DateTimeOffset))
             {
                 return new DefaultDateTimeOffsetValueComparer(favorStructuralComparisons);
             }
 
-            var comparerType = nonNullabletype.IsInteger()
-                || nonNullabletype == typeof(decimal)
-                || nonNullabletype == typeof(bool)
-                || nonNullabletype == typeof(string)
-                || nonNullabletype == typeof(DateTime)
-                || nonNullabletype == typeof(Guid)
-                || nonNullabletype == typeof(TimeSpan)
+            var comparerType = nonNullableType.IsInteger()
+                || nonNullableType == typeof(decimal)
+                || nonNullableType == typeof(bool)
+                || nonNullableType == typeof(string)
+                || nonNullableType == typeof(DateTime)
+                || nonNullableType == typeof(Guid)
+                || nonNullableType == typeof(TimeSpan)
                     ? typeof(DefaultValueComparer<>)
                     : typeof(ValueComparer<>);
 
@@ -253,7 +255,7 @@ public override Expression ExtractSnapshotBody(Expression expression)
             public override object? Snapshot(object? instance)
                 => instance;
 
-            public override T? Snapshot(T? instance)
+            public override T Snapshot(T instance)
                 => instance;
         }
 
diff --git a/src/EFCore/ChangeTracking/ValueComparer`.cs b/src/EFCore/ChangeTracking/ValueComparer`.cs
@@ -33,7 +33,7 @@ public class ValueComparer<T> : ValueComparer, IEqualityComparer<T>
     {
         private Func<T?, T?, bool>? _equals;
         private Func<T, int>? _hashCode;
-        private Func<T?, T?>? _snapshot;
+        private Func<T, T>? _snapshot;
 
         /// <summary>
         ///     Creates a new <see cref="ValueComparer{T}" /> with a default comparison
@@ -82,7 +82,7 @@ public ValueComparer(
         public ValueComparer(
             Expression<Func<T?, T?, bool>> equalsExpression,
             Expression<Func<T, int>> hashCodeExpression,
-            Expression<Func<T?, T?>> snapshotExpression)
+            Expression<Func<T, T>> snapshotExpression)
             : base(equalsExpression, hashCodeExpression, snapshotExpression)
         {
         }
@@ -161,7 +161,7 @@ public ValueComparer(
         ///     Creates an expression for creating a snapshot of a value.
         /// </summary>
         /// <returns> The snapshot expression. </returns>
-        protected static Expression<Func<T?, T?>> CreateDefaultSnapshotExpression(bool favorStructuralComparisons)
+        protected static Expression<Func<T, T>> CreateDefaultSnapshotExpression(bool favorStructuralComparisons)
         {
             if (!favorStructuralComparisons
                 || !typeof(T).IsArray)
@@ -178,7 +178,7 @@ public ValueComparer(
             // var destination = new T[length];
             // Array.Copy(source, destination, length);
             // return destination;
-            return Expression.Lambda<Func<T?, T?>>(
+            return Expression.Lambda<Func<T, T>>(
                 Expression.Block(
                     new[] { lengthVariable, destinationVariable },
                     Expression.Assign(
@@ -257,8 +257,8 @@ public override bool Equals(object? left, object? right)
         /// </summary>
         /// <param name="instance"> The instance. </param>
         /// <returns> The hash code. </returns>
-        public override int GetHashCode(object? instance)
-            => instance == null ? 0 : GetHashCode((T)instance);
+        public override int GetHashCode(object instance)
+            => instance is null ? 0 : GetHashCode((T)instance);
 
         /// <summary>
         ///     Compares the two instances to determine if they are equal.
@@ -293,7 +293,7 @@ public virtual int GetHashCode(T instance)
         /// <param name="instance"> The instance. </param>
         /// <returns> The snapshot. </returns>
         public override object? Snapshot(object? instance)
-            => instance == null ? null : Snapshot((T?)instance);
+            => instance == null ? null : Snapshot((T)instance);
 
         /// <summary>
         ///     <para>
@@ -308,7 +308,7 @@ public virtual int GetHashCode(T instance)
         /// </summary>
         /// <param name="instance"> The instance. </param>
         /// <returns> The snapshot. </returns>
-        public virtual T? Snapshot(T? instance)
+        public virtual T Snapshot(T instance)
             => NonCapturingLazyInitializer.EnsureInitialized(
                 ref _snapshot, this, static c => c.SnapshotExpression.Compile())(instance);
 
@@ -341,7 +341,7 @@ public override Type Type
         ///         reference.
         ///     </para>
         /// </summary>
-        public new virtual Expression<Func<T?, T?>> SnapshotExpression
-            => (Expression<Func<T?, T?>>)base.SnapshotExpression;
+        public new virtual Expression<Func<T, T>> SnapshotExpression
+            => (Expression<Func<T, T>>)base.SnapshotExpression;
     }
 }
diff --git a/test/EFCore.Cosmos.FunctionalTests/EndToEndCosmosTest.cs b/test/EFCore.Cosmos.FunctionalTests/EndToEndCosmosTest.cs
@@ -606,14 +606,13 @@ await Can_add_update_delete_with_collection(
         public async Task Can_add_update_delete_with_nested_collections()
         {
             await Can_add_update_delete_with_collection(
-                new List<List<short>> { new List<short> { 1, 2 } },
+                new List<List<short>> { new() { 1, 2 } },
                 c =>
                 {
                     c.Collection.Clear();
                     c.Collection.Add(new List<short> { 3 });
                 },
-                new List<List<short>> { new List<short> { 3 } });
-
+                new List<List<short>> { new() { 3 } });
             await Can_add_update_delete_with_collection<IList<byte?[]>>(
                 new List<byte?[]>(),
                 c =>
@@ -622,30 +621,29 @@ await Can_add_update_delete_with_collection(
                     c.Collection.Add(null);
                 },
                 new List<byte?[]> { new byte?[] { 3, null }, null });
-
             await Can_add_update_delete_with_collection<IReadOnlyList<Dictionary<string, string>>>(
-                new Dictionary<string, string>[] { new Dictionary<string, string> { { "1", null } } },
+                new Dictionary<string, string>[] { new() { { "1", null } } },
                 c =>
                 {
                     var dictionary = c.Collection[0]["3"] = "2";
                 },
-                new List<Dictionary<string, string>> { new Dictionary<string, string> { { "1", null }, { "3", "2" } } });
+                new List<Dictionary<string, string>> { new() { { "1", null }, { "3", "2" } } });
 
             await Can_add_update_delete_with_collection(
-                new List<float>[] { new List<float> { 1f }, new List<float> { 2 } },
+                new List<float>[] { new() { 1f }, new() { 2 } },
                 c =>
                 {
                     c.Collection[1][0] = 3f;
                 },
-                new List<float>[] { new List<float> { 1f }, new List<float> { 3f } });
+                new List<float>[] { new() { 1f }, new() { 3f } });
 
             await Can_add_update_delete_with_collection(
-                new decimal?[][] { new decimal?[] { 1, null } },
+                new[] { new decimal?[] { 1, null } },
                 c =>
                 {
                     c.Collection[0][1] = 3;
                 },
-                new decimal?[][] { new decimal?[] { 1, 3 } });
+                new[] { new decimal?[] { 1, 3 } });
 
             await Can_add_update_delete_with_collection(
                 new Dictionary<string, List<int>> { { "1", new List<int> { 1 } } },
diff --git a/test/EFCore.Tests/Storage/ValueComparerTest.cs b/test/EFCore.Tests/Storage/ValueComparerTest.cs
@@ -85,7 +85,6 @@ private static ValueComparer CompareTest(Type type, object value1, object value2
             Assert.False(comparer.Equals(null, value2));
             Assert.True(comparer.Equals(null, null));
 
-            Assert.Equal(0, comparer.GetHashCode(null));
             Assert.Equal(hashCode ?? value1.GetHashCode(), comparer.GetHashCode(value1));
 
             var keyComparer = (ValueComparer)Activator.CreateInstance(typeof(ValueComparer<>).MakeGenericType(type), new object[] { true });
@@ -102,7 +101,6 @@ private static ValueComparer CompareTest(Type type, object value1, object value2
             Assert.False(keyComparer.Equals(null, value2));
             Assert.True(keyComparer.Equals(null, null));
 
-            Assert.Equal(0, keyComparer.GetHashCode(null));
             Assert.Equal(hashCode ?? value1.GetHashCode(), keyComparer.GetHashCode(value1));
 
             return comparer;

Original file line number	Diff line number	Diff line change
`@@ -77,13 +77,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme`
`77`	`77`	`return hash.ToHashCode();`
`78`	`78`	`}`
`79`	`79`
`80`		`- private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)`
	`80`	`+ private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)`
`81`	`81`	`{`
`82`		`- if (source is null)`
`83`		`- {`
`84`		`- return null;`
`85`		`- }`
`86`		`-`
`87`	`82`	`if (readOnly)`
`88`	`83`	`{`
`89`	`84`	`return source;`
`@@ -92,7 +87,7 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme`
`92`	`87`	`var snapshot = new List<TElement>(((IReadOnlyList<TElement>)source).Count);`
`93`	`88`	`foreach (var e in source)`
`94`	`89`	`{`
`95`		`- snapshot.Add(elementComparer.Snapshot(e)!);`
	`90`	`+ snapshot.Add(e is null ? default! : elementComparer.Snapshot(e));`
`96`	`91`	`}`
`97`	`92`
`98`	`93`	`return (TCollection)(object)snapshot;`
Original file line number	Diff line number	Diff line change
`@@ -89,13 +89,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme`
`89`	`89`	`return hash.ToHashCode();`
`90`	`90`	`}`
`91`	`91`
`92`		`- private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)`
	`92`	`+ private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)`
`93`	`93`	`{`
`94`		`- if (source is null)`
`95`		`- {`
`96`		`- return null;`
`97`		`- }`
`98`		`-`
`99`	`94`	`if (readOnly)`
`100`	`95`	`{`
`101`	`96`	`return source;`
Original file line number	Diff line number	Diff line change
`@@ -88,13 +88,8 @@ private static int GetHashCode(TElement?[] source, ValueComparer<TElement> eleme`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`[return: NotNullIfNotNull("source")]`
`91`		`- private static TElement?[]? Snapshot(TElement?[]? source, ValueComparer<TElement> elementComparer)`
	`91`	`+ private static TElement?[] Snapshot(TElement?[] source, ValueComparer<TElement> elementComparer)`
`92`	`92`	`{`
`93`		`- if (source is null)`
`94`		`- {`
`95`		`- return null;`
`96`		`- }`
`97`		`-`
`98`	`93`	`var snapshot = new TElement?[source.Length];`
`99`	`94`	`for (var i = 0; i < source.Length; i++)`
`100`	`95`	`{`
Original file line number	Diff line number	Diff line change
`@@ -95,13 +95,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme`
`95`	`95`	`return hash.ToHashCode();`
`96`	`96`	`}`
`97`	`97`
`98`		`- private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)`
	`98`	`+ private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)`
`99`	`99`	`{`
`100`		`- if (source is null)`
`101`		`- {`
`102`		`- return null;`
`103`		`- }`
`104`		`-`
`105`	`100`	`if (readOnly)`
`106`	`101`	`{`
`107`	`102`	`return source;`
Original file line number	Diff line number	Diff line change
`@@ -76,17 +76,13 @@ private static int GetHashCode(TElement[] source, ValueComparer<TElement> elemen`
`76`	`76`	`}`
`77`	`77`
`78`	`78`	`[return: NotNullIfNotNull("source")]`
`79`		`- private static TElement[]? Snapshot(TElement[]? source, ValueComparer<TElement> elementComparer)`
	`79`	`+ private static TElement[] Snapshot(TElement[] source, ValueComparer<TElement> elementComparer)`
`80`	`80`	`{`
`81`		`- if (source is null)`
`82`		`- {`
`83`		`- return null;`
`84`		`- }`
`85`		`-`
`86`	`81`	`var snapshot = new TElement[source.Length];`
`87`	`82`	`for (var i = 0; i < source.Length; i++)`
`88`	`83`	`{`
`89`		`- snapshot[i] = elementComparer.Snapshot(source[i])!;`
	`84`	`+ var element = source[i];`
	`85`	`+ snapshot[i] = element is null ? default! : elementComparer.Snapshot(source[i]);`
`90`	`86`	`}`
`91`	`87`	`return snapshot;`
`92`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -79,13 +79,8 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme`
`79`	`79`	`return hash.ToHashCode();`
`80`	`80`	`}`
`81`	`81`
`82`		`- private static TCollection? Snapshot(TCollection? source, ValueComparer<TElement> elementComparer, bool readOnly)`
	`82`	`+ private static TCollection Snapshot(TCollection source, ValueComparer<TElement> elementComparer, bool readOnly)`
`83`	`83`	`{`
`84`		`- if (source is null)`
`85`		`- {`
`86`		`- return null;`
`87`		`- }`
`88`		`-`
`89`	`84`	`if (readOnly)`
`90`	`85`	`{`
`91`	`86`	`return source;`
`@@ -94,7 +89,7 @@ private static int GetHashCode(TCollection source, ValueComparer<TElement> eleme`
`94`	`89`	`var snapshot = new Dictionary<string, TElement>(((IReadOnlyDictionary<string, TElement>)source).Count);`
`95`	`90`	`foreach (var e in source)`
`96`	`91`	`{`
`97`		`- snapshot.Add(e.Key, elementComparer.Snapshot(e.Value)!);`
	`92`	`+ snapshot.Add(e.Key, e.Value is null ? default! : elementComparer.Snapshot(e.Value));`
`98`	`93`	`}`
`99`	`94`
`100`	`95`	`return (TCollection)(object)snapshot;`
Original file line number	Diff line number	Diff line change
`@@ -24,7 +24,7 @@ public ArrayStructuralComparer()`
`24`	`24`	`: base(`
`25`	`25`	`CreateDefaultEqualsExpression(),`
`26`	`26`	`CreateDefaultHashCodeExpression(favorStructuralComparisons: true),`
`27`		`- v => v == null ? null : v.ToArray())`
	`27`	`+ v => v.ToArray())`
`28`	`28`	`{`
`29`	`29`	`}`
`30`	`30`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ public GeometryValueComparer()`
`58`	`58`	`right);`
`59`	`59`	`}`
`60`	`60`
`61`		`- private static Expression<Func<TGeometry?, TGeometry?>> GetSnapshotExpression()`
	`61`	`+ private static Expression<Func<TGeometry, TGeometry>> GetSnapshotExpression()`
`62`	`62`	`{`
`63`	`63`	`var instance = Expression.Parameter(typeof(TGeometry), "instance");`
`64`	`64`
`@@ -71,7 +71,7 @@ public GeometryValueComparer()`
`71`	`71`	`body = Expression.Convert(body, typeof(TGeometry));`
`72`	`72`	`}`
`73`	`73`
`74`		`- return Expression.Lambda<Func<TGeometry?, TGeometry?>>(body, instance);`
	`74`	`+ return Expression.Lambda<Func<TGeometry, TGeometry>>(body, instance);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -148,7 +148,7 @@ public NoNullsCustomEqualityComparer(ValueComparer comparer)`
`148`	`148`	`public bool Equals(TKey? x, TKey? y)`
`149`	`149`	`=> _equals(x, y);`
`150`	`150`
`151`		`- public int GetHashCode(TKey obj)`
	`151`	`+ public int GetHashCode([DisallowNull] TKey obj)`
`152`	`152`	`=> _hashCode(obj);`
`153`	`153`	`}`
`154`	`154`	`}`