Fix nullability warnings

thomaslevesque · thomaslevesque · commit 4a148b7c4934 · 2021-06-23T23:27:06.000+02:00
diff --git a/src/Linq.Extras/Flatten.cs b/src/Linq.Extras/Flatten.cs
@@ -102,7 +102,7 @@ private static IEnumerable<TResult> DepthFirstFlattenIterator<TNode, TResult>(th
             var list = source.Select(n => new NodeWithLevel<TNode>(n, 0)).ToLinkedList();
             while (list.Count > 0)
             {
-                var current = list.First.Value;
+                var current = list.First!.Value;
                 list.RemoveFirst();
                 yield return resultSelector(current.Node, current.Level);
                 var llNode = list.First;
diff --git a/src/Linq.Extras/Linq.Extras.csproj b/src/Linq.Extras/Linq.Extras.csproj
@@ -15,7 +15,7 @@
     <AssemblyOriginatorKeyFile>..\..\Linq.Extras.snk</AssemblyOriginatorKeyFile>
     <SignAssembly>true</SignAssembly>
     <MinVerVerbosity>quiet</MinVerVerbosity>
-    <LangVersion>8.0</LangVersion>
+    <LangVersion>latest</LangVersion>
     <Nullable>enable</Nullable>
   </PropertyGroup>
 
@@ -29,11 +29,11 @@
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' == 'netcoreapp3.1'">
-    <DefineConstants>$(DefineConstants);FEATURE_NULLABILITY_ATTRIBUTES</DefineConstants>
+    <DefineConstants>$(DefineConstants);FEATURE_NULLABILITY_ATTRIBUTES;FEATURE_COMPARER_NULLABILITY</DefineConstants>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(TargetFramework)' == 'net5.0'">
-    <DefineConstants>$(DefineConstants);FEATURE_NULLABILITY_ATTRIBUTES</DefineConstants>
+    <DefineConstants>$(DefineConstants);FEATURE_NULLABILITY_ATTRIBUTES;FEATURE_COMPARER_NULLABILITY</DefineConstants>
   </PropertyGroup>
 
 </Project>
diff --git a/src/Linq.Extras/OuterJoin.cs b/src/Linq.Extras/OuterJoin.cs
@@ -32,7 +32,7 @@ public static IEnumerable<TResult> LeftOuterJoin<TLeft, TRight, TKey, TResult>(
             [NotNull] Func<TLeft, TKey> leftKeySelector,
             [NotNull] Func<TRight, TKey> rightKeySelector,
             [NotNull] Func<TLeft, TRight, TResult> resultSelector,
-            TRight defaultRight = default,
+            TRight defaultRight = default!,
             IEqualityComparer<TKey>? keyComparer = null)
         {
             left.CheckArgumentNull(nameof(left));
@@ -72,7 +72,7 @@ public static IEnumerable<TResult> RightOuterJoin<TLeft, TRight, TKey, TResult>(
             [NotNull] Func<TLeft, TKey> leftKeySelector,
             [NotNull] Func<TRight, TKey> rightKeySelector,
             [NotNull] Func<TLeft, TRight, TResult> resultSelector,
-            TLeft defaultLeft = default,
+            TLeft defaultLeft = default!,
             IEqualityComparer<TKey>? keyComparer = null)
         {
             left.CheckArgumentNull(nameof(left));
@@ -112,8 +112,8 @@ public static IEnumerable<TResult> FullOuterJoin<TLeft, TRight, TKey, TResult>(
             [NotNull] Func<TLeft, TKey> leftKeySelector,
             [NotNull] Func<TRight, TKey> rightKeySelector,
             [NotNull] Func<TKey, TLeft, TRight, TResult> resultSelector,
-            TLeft defaultLeft = default,
-            TRight defaultRight = default,
+            TLeft defaultLeft = default!,
+            TRight defaultRight = default!,
             IEqualityComparer<TKey>? keyComparer = null)
         {
             left.CheckArgumentNull(nameof(left));
diff --git a/src/Linq.Extras/ToHierarchy.cs b/src/Linq.Extras/ToHierarchy.cs
@@ -23,7 +23,7 @@ public static IEnumerable<INode<TSource>> ToHierarchy<TSource, TId>(
             [NotNull] this IEnumerable<TSource> source,
             [NotNull] Func<TSource, TId> idSelector,
             [NotNull] Func<TSource, TId> parentIdSelector,
-            TId rootParentId = default)
+            TId rootParentId = default!)
         {
             source.CheckArgumentNull(nameof(source));
             idSelector.CheckArgumentNull(nameof(idSelector));
diff --git a/src/Linq.Extras/XComparer.cs b/src/Linq.Extras/XComparer.cs
@@ -182,9 +182,15 @@ public ByKeyComparer(Func<T, TKey> keySelector, IComparer<TKey>? keyComparer)
                 _keyComparer = keyComparer ?? Comparer<TKey>.Default;
             }
 
+#if FEATURE_COMPARER_NULLABILITY
+            public int Compare(T? x, T? y)
+#else
             public int Compare(T x, T y)
+#endif
             {
-                return _keyComparer.Compare(_keySelector(x), _keySelector(y));
+                return _keyComparer.Compare(
+                    x is null ? default! : _keySelector(x),
+                    y is null ? default! : _keySelector(y));
             }
         }
 
@@ -197,7 +203,11 @@ public ReverseComparer(IComparer<T> baseComparer)
                 _baseComparer = baseComparer;
             }
 
+#if FEATURE_COMPARER_NULLABILITY
+            public int Compare(T? x, T? y)
+#else
             public int Compare(T x, T y)
+#endif
             {
                 return _baseComparer.Compare(y, x);
             }
@@ -217,7 +227,11 @@ public ChainedComparer(IEnumerable<IComparer<T>> comparers)
                 Comparers = comparers.ToArray();
             }
 
+#if FEATURE_COMPARER_NULLABILITY
+            public int Compare(T? x, T? y)
+#else
             public int Compare(T x, T y)
+#endif
             {
                 return Comparers.Select(comparer => comparer.Compare(x, y)).FirstOrDefault(cmp => cmp != 0);
             }
@@ -232,10 +246,14 @@ public DelegateComparer(Comparison<T> comparison)
                 _comparison = comparison;
             }
 
+#if FEATURE_COMPARER_NULLABILITY
+            public int Compare(T? x, T? y) => _comparison(x!, y!);
+#else
             public int Compare(T x, T y) => _comparison(x, y);
+#endif
         }
 
-        #endregion
+#endregion
 
     }
 
diff --git a/src/Linq.Extras/XEqualityComparer.cs b/src/Linq.Extras/XEqualityComparer.cs
@@ -43,18 +43,25 @@ public ByKeyEqualityComparer(Func<TSource, TKey> keySelector, IEqualityComparer<
                 _keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;
             }
 
+#if FEATURE_COMPARER_NULLABILITY
+            public bool Equals(TSource? x, TSource? y)
+#else
             public bool Equals(TSource x, TSource y)
+#endif
             {
-                return _keyComparer.Equals(_keySelector(x), _keySelector(y));
+                return _keyComparer.Equals(
+                    x is null ? default! : _keySelector(x),
+                    y is null ? default! : _keySelector(y));
             }
 
             public int GetHashCode(TSource obj)
             {
-                return _keyComparer.GetHashCode(_keySelector(obj));
+                var key = _keySelector(obj);
+                return key is null ? 0 : _keyComparer.GetHashCode(key);
             }
         }
 
-        #endregion
+#endregion
     }
 
     /// <summary>
diff --git a/tests/Linq.Extras.Tests/TestHelper.cs b/tests/Linq.Extras.Tests/TestHelper.cs
@@ -32,16 +32,16 @@ public static void AssertThrowsWhenArgumentNull(Expression<Action> expr)
             var parameters = method.GetParameters();
             var paramIndexes = parameters
                 .Select((p, i) => new { p, i })
-                .ToDictionary(x => x.p.Name, x => x.i);
+                .ToDictionary(x => x.p.Name!, x => x.i);
             var paramTypes = parameters
-                .ToDictionary(p => p.Name, p => p.ParameterType);
+                .ToDictionary(p => p.Name!, p => p.ParameterType);
 
             var nonNullableRefParams = parameters
                 .Where(p => !p.ParameterType.GetTypeInfo().IsValueType && GetNullability(p, defaultNullability) == Nullability.NotNull);
 
             foreach (var param in nonNullableRefParams)
             {
-                var paramName = param.Name;
+                var paramName = param.Name!;
                 var args = realArgs.ToArray();
                 args[paramIndexes[paramName]] = Expression.Constant(null, paramTypes[paramName]);
                 var call = Expression.Call(realCall.Object, method, args);

Original file line number	Diff line number	Diff line change
`@@ -102,7 +102,7 @@ private static IEnumerable<TResult> DepthFirstFlattenIterator<TNode, TResult>(th`
`102`	`102`	`var list = source.Select(n => new NodeWithLevel<TNode>(n, 0)).ToLinkedList();`
`103`	`103`	`while (list.Count > 0)`
`104`	`104`	`{`
`105`		`- var current = list.First.Value;`
	`105`	`+ var current = list.First!.Value;`
`106`	`106`	`list.RemoveFirst();`
`107`	`107`	`yield return resultSelector(current.Node, current.Level);`
`108`	`108`	`var llNode = list.First;`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ public static IEnumerable<INode<TSource>> ToHierarchy<TSource, TId>(`
`23`	`23`	`[NotNull] this IEnumerable<TSource> source,`
`24`	`24`	`[NotNull] Func<TSource, TId> idSelector,`
`25`	`25`	`[NotNull] Func<TSource, TId> parentIdSelector,`
`26`		`- TId rootParentId = default)`
	`26`	`+ TId rootParentId = default!)`
`27`	`27`	`{`
`28`	`28`	`source.CheckArgumentNull(nameof(source));`
`29`	`29`	`idSelector.CheckArgumentNull(nameof(idSelector));`
Original file line number	Diff line number	Diff line change
`@@ -182,9 +182,15 @@ public ByKeyComparer(Func<T, TKey> keySelector, IComparer<TKey>? keyComparer)`
`182`	`182`	`_keyComparer = keyComparer ?? Comparer<TKey>.Default;`
`183`	`183`	`}`
`184`	`184`
	`185`	`+#if FEATURE_COMPARER_NULLABILITY`
	`186`	`+ public int Compare(T? x, T? y)`
	`187`	`+#else`
`185`	`188`	`public int Compare(T x, T y)`
	`189`	`+#endif`
`186`	`190`	`{`
`187`		`- return _keyComparer.Compare(_keySelector(x), _keySelector(y));`
	`191`	`+ return _keyComparer.Compare(`
	`192`	`+ x is null ? default! : _keySelector(x),`
	`193`	`+ y is null ? default! : _keySelector(y));`
`188`	`194`	`}`
`189`	`195`	`}`
`190`	`196`
`@@ -197,7 +203,11 @@ public ReverseComparer(IComparer<T> baseComparer)`
`197`	`203`	`_baseComparer = baseComparer;`
`198`	`204`	`}`
`199`	`205`
	`206`	`+#if FEATURE_COMPARER_NULLABILITY`
	`207`	`+ public int Compare(T? x, T? y)`
	`208`	`+#else`
`200`	`209`	`public int Compare(T x, T y)`
	`210`	`+#endif`
`201`	`211`	`{`
`202`	`212`	`return _baseComparer.Compare(y, x);`
`203`	`213`	`}`
`@@ -217,7 +227,11 @@ public ChainedComparer(IEnumerable<IComparer<T>> comparers)`
`217`	`227`	`Comparers = comparers.ToArray();`
`218`	`228`	`}`
`219`	`229`
	`230`	`+#if FEATURE_COMPARER_NULLABILITY`
	`231`	`+ public int Compare(T? x, T? y)`
	`232`	`+#else`
`220`	`233`	`public int Compare(T x, T y)`
	`234`	`+#endif`
`221`	`235`	`{`
`222`	`236`	`return Comparers.Select(comparer => comparer.Compare(x, y)).FirstOrDefault(cmp => cmp != 0);`
`223`	`237`	`}`
`@@ -232,10 +246,14 @@ public DelegateComparer(Comparison<T> comparison)`
`232`	`246`	`_comparison = comparison;`
`233`	`247`	`}`
`234`	`248`
	`249`	`+#if FEATURE_COMPARER_NULLABILITY`
	`250`	`+ public int Compare(T? x, T? y) => _comparison(x!, y!);`
	`251`	`+#else`
`235`	`252`	`public int Compare(T x, T y) => _comparison(x, y);`
	`253`	`+#endif`
`236`	`254`	`}`
`237`	`255`
`238`		`- #endregion`
	`256`	`+#endregion`
`239`	`257`
`240`	`258`	`}`
`241`	`259`
Original file line number	Diff line number	Diff line change
`@@ -43,18 +43,25 @@ public ByKeyEqualityComparer(Func<TSource, TKey> keySelector, IEqualityComparer<`
`43`	`43`	`_keyComparer = keyComparer ?? EqualityComparer<TKey>.Default;`
`44`	`44`	`}`
`45`	`45`
	`46`	`+#if FEATURE_COMPARER_NULLABILITY`
	`47`	`+ public bool Equals(TSource? x, TSource? y)`
	`48`	`+#else`
`46`	`49`	`public bool Equals(TSource x, TSource y)`
	`50`	`+#endif`
`47`	`51`	`{`
`48`		`- return _keyComparer.Equals(_keySelector(x), _keySelector(y));`
	`52`	`+ return _keyComparer.Equals(`
	`53`	`+ x is null ? default! : _keySelector(x),`
	`54`	`+ y is null ? default! : _keySelector(y));`
`49`	`55`	`}`
`50`	`56`
`51`	`57`	`public int GetHashCode(TSource obj)`
`52`	`58`	`{`
`53`		`- return _keyComparer.GetHashCode(_keySelector(obj));`
	`59`	`+ var key = _keySelector(obj);`
	`60`	`+ return key is null ? 0 : _keyComparer.GetHashCode(key);`
`54`	`61`	`}`
`55`	`62`	`}`
`56`	`63`
`57`		`- #endregion`
	`64`	`+#endregion`
`58`	`65`	`}`
`59`	`66`
`60`	`67`	`/// <summary>`