Merge pull request #1038 from dotnet/dev/bartde/more_null_warnings

bartdesmet · web-flow · commit 3110620385e4 · 2019-09-23T19:09:06.000-07:00
Fix a few more nullability warnings
diff --git a/Ix.NET/Source/Benchmarks.System.Interactive/BufferCountBenchmark.cs b/Ix.NET/Source/Benchmarks.System.Interactive/BufferCountBenchmark.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -15,7 +14,7 @@ public class BufferCountBenchmark
     {
         [Params(1, 10, 100, 1000, 10000, 100000, 1000000)]
         public int N;
-        private IList<int> _store;
+        private IList<int>? _store;
 
         [Benchmark]
         public void Exact()
diff --git a/Ix.NET/Source/Benchmarks.System.Interactive/IgnoreElementsBenchmark.cs b/Ix.NET/Source/Benchmarks.System.Interactive/IgnoreElementsBenchmark.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -18,8 +17,8 @@ public class IgnoreElementsBenchmark
 
         private int _store;
 
-        private int[] _array;
-        private List<int> _list;
+        private int[]? _array;
+        private List<int>? _list;
 
         [Benchmark]
         public void Ignore()
@@ -32,15 +31,15 @@ public void Ignore()
         [Benchmark]
         public void IgnoreList()
         {
-            _list
+            _list!
                 .IgnoreElements()
                 .Subscribe(v => Volatile.Write(ref _store, v));
         }
 
         [Benchmark]
         public void IgnoreArray()
         {
-            _array
+            _array!
                 .IgnoreElements()
                 .Subscribe(v => Volatile.Write(ref _store, v));
         }
diff --git a/Ix.NET/Source/Benchmarks.System.Interactive/MinMaxBenchmark.cs b/Ix.NET/Source/Benchmarks.System.Interactive/MinMaxBenchmark.cs
@@ -2,7 +2,6 @@
 // The .NET Foundation licenses this file to you under the Apache 2.0 License.
 // See the LICENSE file in the project root for more information.
 
-using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading;
@@ -16,7 +15,7 @@ public class MinMaxBenchmark
         [Params(1, 10, 100, 1000, 10000, 100000, 1000000)]
         public int N;
         private int _store;
-        private IList<int> _listStore;
+        private IList<int>? _listStore;
 
         private readonly IComparer<int> _comparer = Comparer<int>.Default;
 
diff --git a/Ix.NET/Source/System.Interactive.Providers/System/Linq/QueryableEx.cs b/Ix.NET/Source/System.Interactive.Providers/System/Linq/QueryableEx.cs
@@ -100,7 +100,7 @@ private static ILookup<string, MethodInfo> GetMethods(Type type)
                 return type.GetMethods(BindingFlags.Static | BindingFlags.Public).ToLookup(m => m.Name);
             }
 
-            private static bool ArgsMatch(MethodInfo method, IList<Expression> arguments, Type[] typeArgs)
+            private static bool ArgsMatch(MethodInfo method, IList<Expression> arguments, Type[]? typeArgs)
             {
                 //
                 // Number of parameters should match. Notice we've sanitized IQueryProvider "this"
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/DistinctUntilChanged.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/DistinctUntilChanged.cs
@@ -80,7 +80,7 @@ public static IEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IEnu
 
         private static IEnumerable<TSource> DistinctUntilChangedCore<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)
         {
-            var currentKey = default(TKey);
+            var currentKey = default(TKey)!;
             var hasCurrentKey = false;
 
             foreach (var item in source)
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Memoize.cs
@@ -113,10 +113,12 @@ public static IEnumerable<TResult> Memoize<TSource, TResult>(this IEnumerable<TS
 
         private sealed class MemoizedBuffer<T> : IBuffer<T>
         {
-            private IRefCountList<T> _buffer;
+            private readonly object _gate = new object();
+            private readonly IRefCountList<T> _buffer;
+            private readonly IEnumerator<T> _source;
+
             private bool _disposed;
             private Exception? _error;
-            private IEnumerator<T> _source;
             private bool _stopped;
 
             public MemoizedBuffer(IEnumerator<T> source)
@@ -153,15 +155,12 @@ IEnumerator IEnumerable.GetEnumerator()
 
             public void Dispose()
             {
-                lock (_source)
+                lock (_gate)
                 {
                     if (!_disposed)
                     {
                         _source.Dispose();
-                        _source = null;
-
                         _buffer.Clear();
-                        _buffer = null;
                     }
 
                     _disposed = true;
@@ -180,9 +179,9 @@ private IEnumerator<T> GetEnumerator_()
                             throw new ObjectDisposedException("");
 
                         var hasValue = default(bool);
-                        var current = default(T);
+                        var current = default(T)!;
 
-                        lock (_source)
+                        lock (_gate)
                         {
                             if (i >= _buffer.Count)
                             {
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/OnErrorResumeNext.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/OnErrorResumeNext.cs
@@ -63,7 +63,7 @@ private static IEnumerable<TSource> OnErrorResumeNextCore<TSource>(IEnumerable<I
 
                 while (true)
                 {
-                    var value = default(TSource);
+                    TSource value;
                     try
                     {
                         if (!innerEnumerator.MoveNext())
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Publish.cs
@@ -62,11 +62,11 @@ public static IEnumerable<TResult> Publish<TSource, TResult>(this IEnumerable<TS
         private sealed class PublishedBuffer<T> : IBuffer<T>
         {
             private readonly object _gate = new object();
+            private readonly RefCountList<T> _buffer;
+            private readonly IEnumerator<T> _source;
 
-            private RefCountList<T> _buffer;
             private bool _disposed;
             private Exception? _error;
-            private IEnumerator<T> _source;
             private bool _stopped;
 
             public PublishedBuffer(IEnumerator<T> source)
@@ -109,10 +109,7 @@ public void Dispose()
                     if (!_disposed)
                     {
                         _source.Dispose();
-                        _source = null;
-
                         _buffer.Clear();
-                        _buffer = null;
                     }
 
                     _disposed = true;
@@ -131,7 +128,7 @@ private IEnumerator<T> GetEnumeratorCore(int i)
                         }
 
                         var hasValue = default(bool);
-                        var current = default(T);
+                        var current = default(T)!;
 
                         lock (_gate)
                         {
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Scan.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Scan.cs
@@ -65,7 +65,7 @@ private static IEnumerable<TAccumulate> ScanCore<TSource, TAccumulate>(IEnumerab
         private static IEnumerable<TSource> ScanCore<TSource>(IEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator)
         {
             var hasSeed = false;
-            var acc = default(TSource);
+            var acc = default(TSource)!;
 
             foreach (var item in source)
             {
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs b/Ix.NET/Source/System.Interactive/System/Linq/Operators/Share.cs
@@ -58,8 +58,8 @@ public static IEnumerable<TResult> Share<TSource, TResult>(this IEnumerable<TSou
 
         private class SharedBuffer<T> : IBuffer<T>
         {
+            private readonly IEnumerator<T> _source;
             private bool _disposed;
-            private IEnumerator<T> _source;
 
             public SharedBuffer(IEnumerator<T> source)
             {
@@ -89,7 +89,6 @@ public void Dispose()
                     if (!_disposed)
                     {
                         _source.Dispose();
-                        _source = null;
                     }
 
                     _disposed = true;
@@ -104,11 +103,15 @@ private sealed class ShareEnumerator : IEnumerator<T>
 
                 private bool _disposed;
 
-                public ShareEnumerator(SharedBuffer<T> parent) => _parent = parent;
+                public ShareEnumerator(SharedBuffer<T> parent)
+                {
+                    _parent = parent;
+                    Current = default!;
+                }
 
                 public T Current { get; private set; }
 
-                object IEnumerator.Current => Current;
+                object? IEnumerator.Current => Current;
 
                 public void Dispose() => _disposed = true;
 
@@ -138,7 +141,7 @@ public bool MoveNext()
                         return true;
                     }
                     _disposed = true;
-                    Current = default;
+                    Current = default!;
                     return false;
                 }
 
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/RefCountList.cs b/Ix.NET/Source/System.Interactive/System/Linq/RefCountList.cs
@@ -45,7 +45,7 @@ public T this[int i]
 
         public void Add(T item)
         {
-            _list[Count] = new RefCount { Value = item, Count = ReaderCount };
+            _list[Count] = new RefCount(item, ReaderCount);
 
             Count++;
         }
@@ -62,8 +62,14 @@ public void Done(int index)
 
         private sealed class RefCount
         {
-            public int Count;
-            public T Value;
+            public RefCount(T value, int count)
+            {
+                Value = value;
+                Count = count;
+            }
+
+            public int Count { get; set; }
+            public T Value { get; }
         }
     }
 }
diff --git a/Ix.NET/Source/System.Interactive/System/Linq/Yielder.cs b/Ix.NET/Source/System.Interactive/System/Linq/Yielder.cs
@@ -14,7 +14,11 @@ internal sealed class Yielder<T> : IYielder<T>, IAwaitable, IAwaiter
         private bool _running;
         private bool _stopped;
 
-        public Yielder(Action<Yielder<T>> create) => _create = create;
+        public Yielder(Action<Yielder<T>> create)
+        {
+            _create = create;
+            Current = default!;
+        }
 
         public T Current { get; private set; }
 
diff --git a/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableRewriter.cs b/Ix.NET/Source/System.Linq.Async.Queryable/System/Linq/AsyncEnumerableRewriter.cs
@@ -58,13 +58,14 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
                 return node;
             }
 
+            var declType = node.Method.DeclaringType;
             var typeArgs = node.Method.IsGenericMethod ? node.Method.GetGenericArguments() : null;
 
             //
             // Check whether the method is compatible with the recursively rewritten instance
             // and arguments expressions. If so, create a new call expression.
             //
-            if ((node.Method.IsStatic || node.Method.DeclaringType.IsAssignableFrom(obj.Type)) && ArgsMatch(node.Method, args, typeArgs))
+            if ((node.Method.IsStatic || declType != null && declType.IsAssignableFrom(obj.Type)) && ArgsMatch(node.Method, args, typeArgs))
             {
                 return Expression.Call(obj, node.Method, args);
             }
@@ -75,15 +76,20 @@ protected override Expression VisitMethodCall(MethodCallExpression node)
             // Find a corresponding method in the non-expression world, e.g. rewriting from
             // the AsyncQueryable methods to the ones on AsyncEnumerable.
             //
-            if (node.Method.DeclaringType == typeof(AsyncQueryable))
+            if (declType == typeof(AsyncQueryable))
             {
                 method = FindEnumerableMethod(node.Method.Name, args, typeArgs);
                 args = FixupQuotedArgs(method, args);
                 return Expression.Call(obj, method, args);
             }
             else
             {
-                method = FindMethod(node.Method.DeclaringType, node.Method.Name, args, typeArgs, BindingFlags.Static | (node.Method.IsPublic ? BindingFlags.Public : BindingFlags.NonPublic));
+                if (declType == null)
+                {
+                    throw new NotSupportedException(string.Format(CultureInfo.InvariantCulture, "Could not rewrite method with name '{0}' without a DeclaringType.", node.Method.Name));
+                }
+
+                method = FindMethod(declType, node.Method.Name, args, typeArgs, BindingFlags.Static | (node.Method.IsPublic ? BindingFlags.Public : BindingFlags.NonPublic));
                 args = FixupQuotedArgs(method, args);
             }
 
diff --git a/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/AsyncEnumerableNamingTests.cs b/Ix.NET/Source/System.Linq.Async.Tests/System/Linq/AsyncEnumerableNamingTests.cs
@@ -68,9 +68,9 @@ select GetDelegateKind(p.ParameterType))
             static bool IsTaskLike(Type t) => IsTask(t) || IsValueTask(t);
 
             static bool IsDelegate(Type t) => typeof(Delegate).IsAssignableFrom(t);
-            static bool TryGetInvoke(Type t, out MethodInfo m) => (m = t.GetMethod("Invoke")) != null;
-            static bool IsAsyncDelegate(Type t) => IsDelegate(t) && TryGetInvoke(t, out var i) && IsTaskLike(i.ReturnType);
-            static bool IsCancelableDelegate(Type t) => IsDelegate(t) && TryGetInvoke(t, out var i) && i.GetParameters().LastOrDefault()?.ParameterType == typeof(CancellationToken);
+            static bool TryGetInvoke(Type t, out MethodInfo? m) => (m = t.GetMethod("Invoke")) != null;
+            static bool IsAsyncDelegate(Type t) => IsDelegate(t) && TryGetInvoke(t, out var i) && IsTaskLike(i!.ReturnType);
+            static bool IsCancelableDelegate(Type t) => IsDelegate(t) && TryGetInvoke(t, out var i) && i!.GetParameters().LastOrDefault()?.ParameterType == typeof(CancellationToken);
             static DelegateKind GetDelegateKind(Type t) => IsAsyncDelegate(t) ? (IsCancelableDelegate(t) ? DelegateKind.AsyncCancel : DelegateKind.Async) : DelegateKind.Sync;
         }
 
diff --git a/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs b/Ix.NET/Source/System.Linq.Async/System/Linq/Operators/SingleLinkedNode.cs
@@ -86,14 +86,14 @@ public SingleLinkedNode<TSource> GetNode(int index)
         {
             Debug.Assert(index >= 0 && index < GetCount());
 
-            SingleLinkedNode<TSource>? node = this;
+            SingleLinkedNode<TSource> node = this;
             for (; index > 0; index--)
             {
-                node = node!.Linked;
+                node = node.Linked!;
+                Debug.Assert(node != null);
             }
 
-            Debug.Assert(node != null);
-            return node;
+            return node!;
         }
 
         /// <summary>

Original file line number	Diff line number	Diff line change
`@@ -100,7 +100,7 @@ private static ILookup<string, MethodInfo> GetMethods(Type type)`
`100`	`100`	`return type.GetMethods(BindingFlags.Static \| BindingFlags.Public).ToLookup(m => m.Name);`
`101`	`101`	`}`
`102`	`102`
`103`		`- private static bool ArgsMatch(MethodInfo method, IList<Expression> arguments, Type[] typeArgs)`
	`103`	`+ private static bool ArgsMatch(MethodInfo method, IList<Expression> arguments, Type[]? typeArgs)`
`104`	`104`	`{`
`105`	`105`	`//`
`106`	`106`	`// Number of parameters should match. Notice we've sanitized IQueryProvider "this"`
Original file line number	Diff line number	Diff line change
`@@ -80,7 +80,7 @@ public static IEnumerable<TSource> DistinctUntilChanged<TSource, TKey>(this IEnu`
`80`	`80`
`81`	`81`	`private static IEnumerable<TSource> DistinctUntilChangedCore<TSource, TKey>(IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> comparer)`
`82`	`82`	`{`
`83`		`- var currentKey = default(TKey);`
	`83`	`+ var currentKey = default(TKey)!;`
`84`	`84`	`var hasCurrentKey = false;`
`85`	`85`
`86`	`86`	`foreach (var item in source)`
Original file line number	Diff line number	Diff line change
`@@ -113,10 +113,12 @@ public static IEnumerable<TResult> Memoize<TSource, TResult>(this IEnumerable<TS`
`113`	`113`
`114`	`114`	`private sealed class MemoizedBuffer<T> : IBuffer<T>`
`115`	`115`	`{`
`116`		`- private IRefCountList<T> _buffer;`
	`116`	`+ private readonly object _gate = new object();`
	`117`	`+ private readonly IRefCountList<T> _buffer;`
	`118`	`+ private readonly IEnumerator<T> _source;`
	`119`	`+`
`117`	`120`	`private bool _disposed;`
`118`	`121`	`private Exception? _error;`
`119`		`- private IEnumerator<T> _source;`
`120`	`122`	`private bool _stopped;`
`121`	`123`
`122`	`124`	`public MemoizedBuffer(IEnumerator<T> source)`
`@@ -153,15 +155,12 @@ IEnumerator IEnumerable.GetEnumerator()`
`153`	`155`
`154`	`156`	`public void Dispose()`
`155`	`157`	`{`
`156`		`- lock (_source)`
	`158`	`+ lock (_gate)`
`157`	`159`	`{`
`158`	`160`	`if (!_disposed)`
`159`	`161`	`{`
`160`	`162`	`_source.Dispose();`
`161`		`- _source = null;`
`162`		`-`
`163`	`163`	`_buffer.Clear();`
`164`		`- _buffer = null;`
`165`	`164`	`}`
`166`	`165`
`167`	`166`	`_disposed = true;`
`@@ -180,9 +179,9 @@ private IEnumerator<T> GetEnumerator_()`
`180`	`179`	`throw new ObjectDisposedException("");`
`181`	`180`
`182`	`181`	`var hasValue = default(bool);`
`183`		`- var current = default(T);`
	`182`	`+ var current = default(T)!;`
`184`	`183`
`185`		`- lock (_source)`
	`184`	`+ lock (_gate)`
`186`	`185`	`{`
`187`	`186`	`if (i >= _buffer.Count)`
`188`	`187`	`{`
Original file line number	Diff line number	Diff line change
`@@ -63,7 +63,7 @@ private static IEnumerable<TSource> OnErrorResumeNextCore<TSource>(IEnumerable<I`
`63`	`63`
`64`	`64`	`while (true)`
`65`	`65`	`{`
`66`		`- var value = default(TSource);`
	`66`	`+ TSource value;`
`67`	`67`	`try`
`68`	`68`	`{`
`69`	`69`	`if (!innerEnumerator.MoveNext())`
Original file line number	Diff line number	Diff line change
`@@ -62,11 +62,11 @@ public static IEnumerable<TResult> Publish<TSource, TResult>(this IEnumerable<TS`
`62`	`62`	`private sealed class PublishedBuffer<T> : IBuffer<T>`
`63`	`63`	`{`
`64`	`64`	`private readonly object _gate = new object();`
	`65`	`+ private readonly RefCountList<T> _buffer;`
	`66`	`+ private readonly IEnumerator<T> _source;`
`65`	`67`
`66`		`- private RefCountList<T> _buffer;`
`67`	`68`	`private bool _disposed;`
`68`	`69`	`private Exception? _error;`
`69`		`- private IEnumerator<T> _source;`
`70`	`70`	`private bool _stopped;`
`71`	`71`
`72`	`72`	`public PublishedBuffer(IEnumerator<T> source)`
`@@ -109,10 +109,7 @@ public void Dispose()`
`109`	`109`	`if (!_disposed)`
`110`	`110`	`{`
`111`	`111`	`_source.Dispose();`
`112`		`- _source = null;`
`113`		`-`
`114`	`112`	`_buffer.Clear();`
`115`		`- _buffer = null;`
`116`	`113`	`}`
`117`	`114`
`118`	`115`	`_disposed = true;`
`@@ -131,7 +128,7 @@ private IEnumerator<T> GetEnumeratorCore(int i)`
`131`	`128`	`}`
`132`	`129`
`133`	`130`	`var hasValue = default(bool);`
`134`		`- var current = default(T);`
	`131`	`+ var current = default(T)!;`
`135`	`132`
`136`	`133`	`lock (_gate)`
`137`	`134`	`{`
Original file line number	Diff line number	Diff line change
`@@ -65,7 +65,7 @@ private static IEnumerable<TAccumulate> ScanCore<TSource, TAccumulate>(IEnumerab`
`65`	`65`	`private static IEnumerable<TSource> ScanCore<TSource>(IEnumerable<TSource> source, Func<TSource, TSource, TSource> accumulator)`
`66`	`66`	`{`
`67`	`67`	`var hasSeed = false;`
`68`		`- var acc = default(TSource);`
	`68`	`+ var acc = default(TSource)!;`
`69`	`69`
`70`	`70`	`foreach (var item in source)`
`71`	`71`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,8 @@ public static IEnumerable<TResult> Share<TSource, TResult>(this IEnumerable<TSou`
`58`	`58`
`59`	`59`	`private class SharedBuffer<T> : IBuffer<T>`
`60`	`60`	`{`
	`61`	`+ private readonly IEnumerator<T> _source;`
`61`	`62`	`private bool _disposed;`
`62`		`- private IEnumerator<T> _source;`
`63`	`63`
`64`	`64`	`public SharedBuffer(IEnumerator<T> source)`
`65`	`65`	`{`
`@@ -89,7 +89,6 @@ public void Dispose()`
`89`	`89`	`if (!_disposed)`
`90`	`90`	`{`
`91`	`91`	`_source.Dispose();`
`92`		`- _source = null;`
`93`	`92`	`}`
`94`	`93`
`95`	`94`	`_disposed = true;`
`@@ -104,11 +103,15 @@ private sealed class ShareEnumerator : IEnumerator<T>`
`104`	`103`
`105`	`104`	`private bool _disposed;`
`106`	`105`
`107`		`- public ShareEnumerator(SharedBuffer<T> parent) => _parent = parent;`
	`106`	`+ public ShareEnumerator(SharedBuffer<T> parent)`
	`107`	`+ {`
	`108`	`+ _parent = parent;`
	`109`	`+ Current = default!;`
	`110`	`+ }`
`108`	`111`
`109`	`112`	`public T Current { get; private set; }`
`110`	`113`
`111`		`- object IEnumerator.Current => Current;`
	`114`	`+ object? IEnumerator.Current => Current;`
`112`	`115`
`113`	`116`	`public void Dispose() => _disposed = true;`
`114`	`117`
`@@ -138,7 +141,7 @@ public bool MoveNext()`
`138`	`141`	`return true;`
`139`	`142`	`}`
`140`	`143`	`_disposed = true;`
`141`		`- Current = default;`
	`144`	`+ Current = default!;`
`142`	`145`	`return false;`
`143`	`146`	`}`
`144`	`147`