Merge pull request #1376 from dotnet/dev/bartde/fix_warnings

bartdesmet · web-flow · commit 46d83e38c6bd · 2020-10-05T15:48:48.000-07:00
Fix a number of warnings.
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Services.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Services.cs
@@ -70,7 +70,7 @@ public static partial class Scheduler
         {
             if (scheduler is IServiceProvider svc)
             {
-                return (T)svc.GetService(typeof(T));
+                return (T?)svc.GetService(typeof(T));
             }
 
             return null;
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Simple.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Simple.cs
@@ -34,7 +34,7 @@ public static IDisposable Schedule(this IScheduler scheduler, Action action)
             // the anonymous lambda can be replaced by the method group again. Until then,
             // to avoid the repetition of code, the call to Invoke is left intact.
             // Watch https://github.com/dotnet/roslyn/issues/5835
-            return scheduler.Schedule(action, static (s, a) => Invoke(s, a));
+            return scheduler.Schedule(action, static (_, a) => Invoke(a));
         }
 
         /// <summary>
@@ -109,7 +109,7 @@ public static IDisposable Schedule(this IScheduler scheduler, TimeSpan dueTime,
             }
 
             // See note above.
-            return scheduler.Schedule(action, dueTime, static (s, a) => Invoke(s, a));
+            return scheduler.Schedule(action, dueTime, static (_, a) => Invoke(a));
         }
 
         /// <summary>
@@ -134,7 +134,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS
             }
 
             // See note above.
-            return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));
+            return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));
         }
 
         /// <summary>
@@ -154,7 +154,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS
                 throw new ArgumentNullException(nameof(action));
 
             // See note above.
-            return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));
+            return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));
         }
 
         /// <summary>
@@ -178,7 +178,7 @@ public static IDisposable Schedule(this IScheduler scheduler, DateTimeOffset due
             }
 
             // See note above.
-            return scheduler.Schedule(action, dueTime, static (s, a) => Invoke(s, a));
+            return scheduler.Schedule(action, dueTime, static (_, a) => Invoke(a));
         }
 
         /// <summary>
@@ -203,7 +203,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS
             }
 
             // See note above.
-            return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));
+            return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));
         }
 
         /// <summary>
@@ -223,7 +223,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS
                 throw new ArgumentNullException(nameof(action));
 
             // See note above.
-            return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));
+            return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));
         }
 
         /// <summary>
@@ -248,19 +248,19 @@ public static IDisposable ScheduleLongRunning(this ISchedulerLongRunning schedul
             return scheduler.ScheduleLongRunning(action, static (a, c) => a(c));
         }
 
-        private static IDisposable Invoke(IScheduler scheduler, Action action)
+        private static IDisposable Invoke(Action action)
         {
             action();
             return Disposable.Empty;
         }
 
-        private static IDisposable Invoke<TState>(IScheduler scheduler, (TState state, Action<TState> action) tuple)
+        private static IDisposable Invoke<TState>((TState state, Action<TState> action) tuple)
         {
             tuple.action(tuple.state);
             return Disposable.Empty;
         }
 
-        private static IDisposable Invoke<TState>(IScheduler scheduler, (TState state, Func<TState, IDisposable> action) tuple)
+        private static IDisposable Invoke<TState>((TState state, Func<TState, IDisposable> action) tuple)
         {
             return tuple.action(tuple.state);
         }
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/Synchronization.ObserveOn.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/Synchronization.ObserveOn.cs
@@ -112,17 +112,17 @@ public override void OnCompleted()
                     _context.Post(OnCompletedPosted, state: null);
                 }
 
-                private void OnNextPosted(object value)
+                private void OnNextPosted(object? value)
                 {
-                    ForwardOnNext((TSource)value);
+                    ForwardOnNext((TSource)value!);
                 }
 
-                private void OnErrorPosted(object error)
+                private void OnErrorPosted(object? error)
                 {
-                    ForwardOnError((Exception)error);
+                    ForwardOnError((Exception)error!);
                 }
 
-                private void OnCompletedPosted(object ignored)
+                private void OnCompletedPosted(object? ignored)
                 {
                     ForwardOnCompleted();
                 }
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/VirtualTimeScheduler.Extensions.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/VirtualTimeScheduler.Extensions.cs
@@ -38,7 +38,7 @@ public static IDisposable ScheduleRelative<TAbsolute, TRelative>(this VirtualTim
             // an anonymous delegate will allow delegate caching.
             // Watch https://github.com/dotnet/roslyn/issues/5835 for compiler
             // support for caching delegates from method groups.
-            return scheduler.ScheduleRelative(action, dueTime, static (s, a) => Invoke(s, a));
+            return scheduler.ScheduleRelative(action, dueTime, static (_, a) => Invoke(a));
         }
 
         /// <summary>
@@ -64,10 +64,10 @@ public static IDisposable ScheduleAbsolute<TAbsolute, TRelative>(this VirtualTim
                 throw new ArgumentNullException(nameof(action));
             }
 
-            return scheduler.ScheduleAbsolute(action, dueTime, static (s, a) => Invoke(s, a));
+            return scheduler.ScheduleAbsolute(action, dueTime, static (_, a) => Invoke(a));
         }
 
-        private static IDisposable Invoke(IScheduler scheduler, Action action)
+        private static IDisposable Invoke(Action action)
         {
             action();
             return Disposable.Empty;
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/HostLifecycleNotifications.Windows.cs b/Rx.NET/Source/src/System.Reactive/Internal/HostLifecycleNotifications.Windows.cs
@@ -10,8 +10,8 @@ namespace System.Reactive.PlatformServices
 {
     internal class HostLifecycleNotifications : IHostLifecycleNotifications
     {
-        private EventHandler<SuspendingEventArgs> _suspending;
-        private EventHandler<object> _resuming;
+        private EventHandler<SuspendingEventArgs>? _suspending;
+        private EventHandler<object>? _resuming;
 
         public event EventHandler<HostSuspendingEventArgs> Suspending
         {
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs b/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs
@@ -436,7 +436,7 @@ protected override void Dispose(bool disposing)
         /// _queue field is not re-read from memory unnecessarily
         /// due to the memory barriers inside TryDequeue mandating it
         /// despite the field is read-only.</param>
-        private void Clear(ConcurrentQueue<T> q)
+        private static void Clear(ConcurrentQueue<T> q)
         {
             while (q.TryDequeue(out var _))
             {
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/FromEvent.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/FromEvent.cs
@@ -178,7 +178,7 @@ protected override TDelegate GetHandler(Action<TEventArgs> onNext)
 
             if (_conversion == null)
             {
-                handler = ReflectionUtils.CreateDelegate<TDelegate>(onNext, typeof(Action<TEventArgs>).GetMethod(nameof(Action<TEventArgs>.Invoke)));
+                handler = ReflectionUtils.CreateDelegate<TDelegate>(onNext, typeof(Action<TEventArgs>).GetMethod(nameof(Action<TEventArgs>.Invoke))!);
             }
             else
             {
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/FromEventPattern.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/FromEventPattern.cs
@@ -37,7 +37,7 @@ protected override TDelegate GetHandler(Action<EventPattern<TEventArgs>> onNext)
                 if (_conversion == null)
                 {
                     Action<object, TEventArgs> h = (sender, eventArgs) => onNext(new EventPattern<TEventArgs>(sender, eventArgs));
-                    handler = ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<object, TEventArgs>).GetMethod(nameof(Action<object, TEventArgs>.Invoke)));
+                    handler = ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<object, TEventArgs>).GetMethod(nameof(Action<object, TEventArgs>.Invoke))!);
                 }
                 else
                 {
@@ -58,7 +58,7 @@ public Impl(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, ISche
             protected override TDelegate GetHandler(Action<EventPattern<TSender, TEventArgs>> onNext)
             {
                 Action<TSender, TEventArgs> h = (sender, eventArgs) => onNext(new EventPattern<TSender, TEventArgs>(sender, eventArgs));
-                return ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke)));
+                return ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke))!);
             }
         }
 
@@ -91,7 +91,7 @@ public Handler(object? target, Type delegateType, MethodInfo addMethod, MethodIn
             protected override Delegate GetHandler(Action<TResult> onNext)
             {
                 Action<TSender, TEventArgs> h = (sender, eventArgs) => onNext(_getResult(sender, eventArgs));
-                return ReflectionUtils.CreateDelegate(_delegateType, h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke)));
+                return ReflectionUtils.CreateDelegate(_delegateType, h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke))!);
             }
 
             protected override IDisposable AddHandler(Delegate handler)
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/SelectMany.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/SelectMany.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information. 
 
 using System.Collections.Generic;
+using System.Reactive.Concurrency;
 using System.Reactive.Disposables;
 using System.Threading;
 using System.Threading.Tasks;
@@ -629,7 +630,7 @@ private void OnCompletedTask(TSource value, Task<TCollection> task)
                         {
                             lock (_gate)
                             {
-                                ForwardOnError(task.Exception.InnerException);
+                                ForwardOnError(TaskHelpers.GetSingleException(task));
                             }
 
                             break;
@@ -786,7 +787,7 @@ private void OnCompletedTask(TSource value, int index, Task<TCollection> task)
                         {
                             lock (_gate)
                             {
-                                ForwardOnError(task.Exception.InnerException);
+                                ForwardOnError(TaskHelpers.GetSingleException(task));
                             }
 
                             break;
@@ -1532,7 +1533,7 @@ public override void OnNext(TSource value)
                     }
                     else
                     {
-                        task.ContinueWith((closureTask, thisObject) => ((_)thisObject).OnCompletedTask(closureTask), this, _cts.Token);
+                        task.ContinueWith((closureTask, thisObject) => ((_)thisObject!).OnCompletedTask(closureTask), this, _cts.Token);
                     }
                 }
 
@@ -1555,7 +1556,7 @@ private void OnCompletedTask(Task<TResult> task)
                         {
                             lock (_gate)
                             {
-                                ForwardOnError(task.Exception.InnerException);
+                                ForwardOnError(TaskHelpers.GetSingleException(task));
                             }
 
                             break;
@@ -1667,7 +1668,7 @@ public override void OnNext(TSource value)
                     }
                     else
                     {
-                        task.ContinueWith((closureTask, thisObject) => ((_)thisObject).OnCompletedTask(closureTask), this, _cts.Token);
+                        task.ContinueWith((closureTask, thisObject) => ((_)thisObject!).OnCompletedTask(closureTask), this, _cts.Token);
                     }
                 }
 
@@ -1690,7 +1691,7 @@ private void OnCompletedTask(Task<TResult> task)
                         {
                             lock (_gate)
                             {
-                                ForwardOnError(task.Exception.InnerException);
+                                ForwardOnError(TaskHelpers.GetSingleException(task));
                             }
 
                             break;
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Qbservable.Joins.cs b/Rx.NET/Source/src/System.Reactive/Linq/Qbservable.Joins.cs
@@ -45,7 +45,7 @@ public static QueryablePattern<TLeft, TRight> And<TLeft, TRight>(this IQbservabl
 #if CRIPPLED_REFLECTION
                     InfoOf(() => And<TLeft, TRight>(default, default)),
 #else
-                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TLeft), typeof(TRight)),
+                    ((MethodInfo)MethodBase.GetCurrentMethod()!).MakeGenericMethod(typeof(TLeft), typeof(TRight)),
 #endif
                     left.Expression,
                     GetSourceExpression(right)
@@ -80,7 +80,7 @@ public static QueryablePlan<TResult> Then<TSource, TResult>(this IQbservable<TSo
 #if CRIPPLED_REFLECTION
                     InfoOf(() => Then<TSource, TResult>(default, default)),
 #else
-                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource), typeof(TResult)),
+                    ((MethodInfo)MethodBase.GetCurrentMethod()!).MakeGenericMethod(typeof(TSource), typeof(TResult)),
 #endif
                     source.Expression,
                     selector
@@ -114,7 +114,7 @@ public static IQbservable<TResult> When<TResult>(this IQbservableProvider provid
 #if CRIPPLED_REFLECTION
                     InfoOf(() => When<TResult>(default, default)),
 #else
-                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)),
+                    ((MethodInfo)MethodBase.GetCurrentMethod()!).MakeGenericMethod(typeof(TResult)),
 #endif
                     Expression.Constant(provider, typeof(IQbservableProvider)),
                     Expression.NewArrayInit(
@@ -151,7 +151,7 @@ public static IQbservable<TResult> When<TResult>(this IQbservableProvider provid
 #if CRIPPLED_REFLECTION
                     InfoOf(() => When(default, default(IEnumerable<QueryablePlan<TResult>>))),
 #else
-                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TResult)),
+                    ((MethodInfo)MethodBase.GetCurrentMethod()!).MakeGenericMethod(typeof(TResult)),
 #endif
                     Expression.Constant(provider, typeof(IQbservableProvider)),
                     Expression.Constant(plans, typeof(IEnumerable<QueryablePlan<TResult>>))
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Qbservable.cs b/Rx.NET/Source/src/System.Reactive/Linq/Qbservable.cs
@@ -56,7 +56,7 @@ public static IQbservable<TSource> ToQbservable<TSource>(this IQueryable<TSource
 #if CRIPPLED_REFLECTION
                     InfoOf(() => ToQbservable<TSource>(default)),
 #else
-                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)),
+                    ((MethodInfo)MethodBase.GetCurrentMethod()!).MakeGenericMethod(typeof(TSource)),
 #endif
                     source.Expression
                 )
@@ -90,7 +90,7 @@ public static IQbservable<TSource> ToQbservable<TSource>(this IQueryable<TSource
 #if CRIPPLED_REFLECTION
                     InfoOf(() => ToQbservable<TSource>(default)),
 #else
-                    ((MethodInfo)MethodBase.GetCurrentMethod()).MakeGenericMethod(typeof(TSource)),
+                    ((MethodInfo)MethodBase.GetCurrentMethod()!).MakeGenericMethod(typeof(TSource)),
 #endif
                     source.Expression,
                     Expression.Constant(scheduler)
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.cs b/Rx.NET/Source/src/System.Reactive/Linq/QbservableEx.NAry.cs
@@ -2,7 +2,7 @@
 // The .NET Foundation licenses this file to you under the MIT License.
 // See the LICENSE file in the project root for more information. 
 
-// This code was generated by a T4 template at 10/05/2020 14:10:15.
+// This code was generated by a T4 template at 10/05/2020 15:28:51.
 
 using System.Linq.Expressions;
 #if !CRIPPLED_REFLECTION
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.cs b/Rx.NET/Source/src/System.Reactive/Linq/QueryLanguage.Multiple.cs
@@ -142,7 +142,7 @@ public virtual IObservable<TSource> Concat<TSource>(IObservable<Task<TSource>> s
             return Concat_(Select(sources, TaskObservableExtensions.ToObservable));
         }
 
-        private IObservable<TSource> Concat_<TSource>(IObservable<IObservable<TSource>> sources)
+        private static IObservable<TSource> Concat_<TSource>(IObservable<IObservable<TSource>> sources)
         {
             return new ConcatMany<TSource>(sources);
         }
@@ -263,7 +263,7 @@ public virtual IObservable<TSource> Switch<TSource>(IObservable<Task<TSource>> s
             return Switch_(Select(sources, TaskObservableExtensions.ToObservable));
         }
 
-        private IObservable<TSource> Switch_<TSource>(IObservable<IObservable<TSource>> sources)
+        private static IObservable<TSource> Switch_<TSource>(IObservable<IObservable<TSource>> sources)
         {
             return new Switch<TSource>(sources);
         }
diff --git a/Rx.NET/Source/src/System.Reactive/ObservableQuery.cs b/Rx.NET/Source/src/System.Reactive/ObservableQuery.cs
@@ -207,7 +207,7 @@ protected override Expression VisitMethodCall(MethodCallExpression/*!*/ node)
                         //
                         var pattern = Visit(node.Object);
                         var arguments = node.Arguments.Select(arg => Unquote(Visit(arg))).ToArray();
-                        var then = Expression.Call(pattern, "Then", method.GetGenericArguments(), arguments);
+                        var then = Expression.Call(pattern!, method.Name, method.GetGenericArguments(), arguments);
                         return then;
                     }
 
@@ -218,7 +218,7 @@ protected override Expression VisitMethodCall(MethodCallExpression/*!*/ node)
                         //
                         var lhs = Visit(node.Object);
                         var arguments = node.Arguments.Select(arg => Visit(arg)).ToArray();
-                        var and = Expression.Call(lhs, "And", method.GetGenericArguments(), arguments);
+                        var and = Expression.Call(lhs!, method.Name, method.GetGenericArguments(), arguments);
                         return and;
                     }
                 }
diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Concurrency/CoreDispatcherScheduler.cs b/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Concurrency/CoreDispatcherScheduler.cs
@@ -11,13 +11,14 @@
 #if HAS_OS_XAML
 using Windows.UI.Xaml;
 #endif
+
 namespace System.Reactive.Concurrency
 {
     /// <summary>
     /// Represents an object that schedules units of work on a <see cref="CoreDispatcher"/>.
     /// </summary>
     /// <remarks>
-    /// This scheduler type is typically used indirectly through the <see cref="Linq.DispatcherObservable.ObserveOnDispatcher{TSource}(IObservable{TSource})"/> and <see cref="Linq.DispatcherObservable.SubscribeOnDispatcher{TSource}(IObservable{TSource})"/> methods that use the current Dispatcher.
+    /// This scheduler type is typically used indirectly through the <see cref="Linq.CoreDispatcherObservable.ObserveOnCoreDispatcher{TSource}(IObservable{TSource})"/> and <see cref="Linq.CoreDispatcherObservable.SubscribeOnCoreDispatcher{TSource}(IObservable{TSource})"/> methods that use the current CoreDispatcher.
     /// </remarks>
     [CLSCompliant(false)]
     public sealed class CoreDispatcherScheduler : LocalScheduler, ISchedulerPeriodic
diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/EventPatternSource.cs b/Rx.NET/Source/src/System.Reactive/Platforms/UWP/EventPatternSource.cs
@@ -18,7 +18,7 @@ event TypedEventHandler<TSender, TEventArgs> IEventPatternSource<TSender, TEvent
         {
             add
             {
-                Add(value, (o, e) => value(o, e));
+                Add(value, (o, e) => value(o!, e));
             }
 
             remove
diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/CoreDispatcherObservable.cs b/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/CoreDispatcherObservable.cs
diff --git a/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.Events.cs b/Rx.NET/Source/src/System.Reactive/Platforms/UWP/Linq/WindowsObservable.Events.cs

Original file line number	Diff line number	Diff line change
`@@ -70,7 +70,7 @@ public static partial class Scheduler`
`70`	`70`	`{`
`71`	`71`	`if (scheduler is IServiceProvider svc)`
`72`	`72`	`{`
`73`		`- return (T)svc.GetService(typeof(T));`
	`73`	`+ return (T?)svc.GetService(typeof(T));`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`return null;`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ public static IDisposable Schedule(this IScheduler scheduler, Action action)`
`34`	`34`	`// the anonymous lambda can be replaced by the method group again. Until then,`
`35`	`35`	`// to avoid the repetition of code, the call to Invoke is left intact.`
`36`	`36`	`// Watch https://github.com/dotnet/roslyn/issues/5835`
`37`		`- return scheduler.Schedule(action, static (s, a) => Invoke(s, a));`
	`37`	`+ return scheduler.Schedule(action, static (_, a) => Invoke(a));`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`/// <summary>`
`@@ -109,7 +109,7 @@ public static IDisposable Schedule(this IScheduler scheduler, TimeSpan dueTime,`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`// See note above.`
`112`		`- return scheduler.Schedule(action, dueTime, static (s, a) => Invoke(s, a));`
	`112`	`+ return scheduler.Schedule(action, dueTime, static (_, a) => Invoke(a));`
`113`	`113`	`}`
`114`	`114`
`115`	`115`	`/// <summary>`
`@@ -134,7 +134,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS`
`134`	`134`	`}`
`135`	`135`
`136`	`136`	`// See note above.`
`137`		`- return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));`
	`137`	`+ return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	`/// <summary>`
`@@ -154,7 +154,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS`
`154`	`154`	`throw new ArgumentNullException(nameof(action));`
`155`	`155`
`156`	`156`	`// See note above.`
`157`		`- return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));`
	`157`	`+ return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`/// <summary>`
`@@ -178,7 +178,7 @@ public static IDisposable Schedule(this IScheduler scheduler, DateTimeOffset due`
`178`	`178`	`}`
`179`	`179`
`180`	`180`	`// See note above.`
`181`		`- return scheduler.Schedule(action, dueTime, static (s, a) => Invoke(s, a));`
	`181`	`+ return scheduler.Schedule(action, dueTime, static (_, a) => Invoke(a));`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`/// <summary>`
`@@ -203,7 +203,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS`
`203`	`203`	`}`
`204`	`204`
`205`	`205`	`// See note above.`
`206`		`- return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));`
	`206`	`+ return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`/// <summary>`
`@@ -223,7 +223,7 @@ internal static IDisposable ScheduleAction<TState>(this IScheduler scheduler, TS`
`223`	`223`	`throw new ArgumentNullException(nameof(action));`
`224`	`224`
`225`	`225`	`// See note above.`
`226`		`- return scheduler.Schedule((state, action), dueTime, static (s, tuple) => Invoke(s, tuple));`
	`226`	`+ return scheduler.Schedule((state, action), dueTime, static (_, tuple) => Invoke(tuple));`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`/// <summary>`
`@@ -248,19 +248,19 @@ public static IDisposable ScheduleLongRunning(this ISchedulerLongRunning schedul`
`248`	`248`	`return scheduler.ScheduleLongRunning(action, static (a, c) => a(c));`
`249`	`249`	`}`
`250`	`250`
`251`		`- private static IDisposable Invoke(IScheduler scheduler, Action action)`
	`251`	`+ private static IDisposable Invoke(Action action)`
`252`	`252`	`{`
`253`	`253`	`action();`
`254`	`254`	`return Disposable.Empty;`
`255`	`255`	`}`
`256`	`256`
`257`		`- private static IDisposable Invoke<TState>(IScheduler scheduler, (TState state, Action<TState> action) tuple)`
	`257`	`+ private static IDisposable Invoke<TState>((TState state, Action<TState> action) tuple)`
`258`	`258`	`{`
`259`	`259`	`tuple.action(tuple.state);`
`260`	`260`	`return Disposable.Empty;`
`261`	`261`	`}`
`262`	`262`
`263`		`- private static IDisposable Invoke<TState>(IScheduler scheduler, (TState state, Func<TState, IDisposable> action) tuple)`
	`263`	`+ private static IDisposable Invoke<TState>((TState state, Func<TState, IDisposable> action) tuple)`
`264`	`264`	`{`
`265`	`265`	`return tuple.action(tuple.state);`
`266`	`266`	`}`
Original file line number	Diff line number	Diff line change
`@@ -112,17 +112,17 @@ public override void OnCompleted()`
`112`	`112`	`_context.Post(OnCompletedPosted, state: null);`
`113`	`113`	`}`
`114`	`114`
`115`		`- private void OnNextPosted(object value)`
	`115`	`+ private void OnNextPosted(object? value)`
`116`	`116`	`{`
`117`		`- ForwardOnNext((TSource)value);`
	`117`	`+ ForwardOnNext((TSource)value!);`
`118`	`118`	`}`
`119`	`119`
`120`		`- private void OnErrorPosted(object error)`
	`120`	`+ private void OnErrorPosted(object? error)`
`121`	`121`	`{`
`122`		`- ForwardOnError((Exception)error);`
	`122`	`+ ForwardOnError((Exception)error!);`
`123`	`123`	`}`
`124`	`124`
`125`		`- private void OnCompletedPosted(object ignored)`
	`125`	`+ private void OnCompletedPosted(object? ignored)`
`126`	`126`	`{`
`127`	`127`	`ForwardOnCompleted();`
`128`	`128`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public static IDisposable ScheduleRelative<TAbsolute, TRelative>(this VirtualTim`
`38`	`38`	`// an anonymous delegate will allow delegate caching.`
`39`	`39`	`// Watch https://github.com/dotnet/roslyn/issues/5835 for compiler`
`40`	`40`	`// support for caching delegates from method groups.`
`41`		`- return scheduler.ScheduleRelative(action, dueTime, static (s, a) => Invoke(s, a));`
	`41`	`+ return scheduler.ScheduleRelative(action, dueTime, static (_, a) => Invoke(a));`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// <summary>`
`@@ -64,10 +64,10 @@ public static IDisposable ScheduleAbsolute<TAbsolute, TRelative>(this VirtualTim`
`64`	`64`	`throw new ArgumentNullException(nameof(action));`
`65`	`65`	`}`
`66`	`66`
`67`		`- return scheduler.ScheduleAbsolute(action, dueTime, static (s, a) => Invoke(s, a));`
	`67`	`+ return scheduler.ScheduleAbsolute(action, dueTime, static (_, a) => Invoke(a));`
`68`	`68`	`}`
`69`	`69`
`70`		`- private static IDisposable Invoke(IScheduler scheduler, Action action)`
	`70`	`+ private static IDisposable Invoke(Action action)`
`71`	`71`	`{`
`72`	`72`	`action();`
`73`	`73`	`return Disposable.Empty;`
Original file line number	Diff line number	Diff line change
`@@ -10,8 +10,8 @@ namespace System.Reactive.PlatformServices`
`10`	`10`	`{`
`11`	`11`	`internal class HostLifecycleNotifications : IHostLifecycleNotifications`
`12`	`12`	`{`
`13`		`- private EventHandler<SuspendingEventArgs> _suspending;`
`14`		`- private EventHandler<object> _resuming;`
	`13`	`+ private EventHandler<SuspendingEventArgs>? _suspending;`
	`14`	`+ private EventHandler<object>? _resuming;`
`15`	`15`
`16`	`16`	`public event EventHandler<HostSuspendingEventArgs> Suspending`
`17`	`17`	`{`
Original file line number	Diff line number	Diff line change
`@@ -436,7 +436,7 @@ protected override void Dispose(bool disposing)`
`436`	`436`	`/// _queue field is not re-read from memory unnecessarily`
`437`	`437`	`/// due to the memory barriers inside TryDequeue mandating it`
`438`	`438`	`/// despite the field is read-only.</param>`
`439`		`- private void Clear(ConcurrentQueue<T> q)`
	`439`	`+ private static void Clear(ConcurrentQueue<T> q)`
`440`	`440`	`{`
`441`	`441`	`while (q.TryDequeue(out var _))`
`442`	`442`	`{`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ protected override TDelegate GetHandler(Action<TEventArgs> onNext)`
`178`	`178`
`179`	`179`	`if (_conversion == null)`
`180`	`180`	`{`
`181`		`- handler = ReflectionUtils.CreateDelegate<TDelegate>(onNext, typeof(Action<TEventArgs>).GetMethod(nameof(Action<TEventArgs>.Invoke)));`
	`181`	`+ handler = ReflectionUtils.CreateDelegate<TDelegate>(onNext, typeof(Action<TEventArgs>).GetMethod(nameof(Action<TEventArgs>.Invoke))!);`
`182`	`182`	`}`
`183`	`183`	`else`
`184`	`184`	`{`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ protected override TDelegate GetHandler(Action<EventPattern<TEventArgs>> onNext)`
`37`	`37`	`if (_conversion == null)`
`38`	`38`	`{`
`39`	`39`	`Action<object, TEventArgs> h = (sender, eventArgs) => onNext(new EventPattern<TEventArgs>(sender, eventArgs));`
`40`		`- handler = ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<object, TEventArgs>).GetMethod(nameof(Action<object, TEventArgs>.Invoke)));`
	`40`	`+ handler = ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<object, TEventArgs>).GetMethod(nameof(Action<object, TEventArgs>.Invoke))!);`
`41`	`41`	`}`
`42`	`42`	`else`
`43`	`43`	`{`
`@@ -58,7 +58,7 @@ public Impl(Action<TDelegate> addHandler, Action<TDelegate> removeHandler, ISche`
`58`	`58`	`protected override TDelegate GetHandler(Action<EventPattern<TSender, TEventArgs>> onNext)`
`59`	`59`	`{`
`60`	`60`	`Action<TSender, TEventArgs> h = (sender, eventArgs) => onNext(new EventPattern<TSender, TEventArgs>(sender, eventArgs));`
`61`		`- return ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke)));`
	`61`	`+ return ReflectionUtils.CreateDelegate<TDelegate>(h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke))!);`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`@@ -91,7 +91,7 @@ public Handler(object? target, Type delegateType, MethodInfo addMethod, MethodIn`
`91`	`91`	`protected override Delegate GetHandler(Action<TResult> onNext)`
`92`	`92`	`{`
`93`	`93`	`Action<TSender, TEventArgs> h = (sender, eventArgs) => onNext(_getResult(sender, eventArgs));`
`94`		`- return ReflectionUtils.CreateDelegate(_delegateType, h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke)));`
	`94`	`+ return ReflectionUtils.CreateDelegate(_delegateType, h, typeof(Action<TSender, TEventArgs>).GetMethod(nameof(Action<TSender, TEventArgs>.Invoke))!);`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`protected override IDisposable AddHandler(Delegate handler)`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`// See the LICENSE file in the project root for more information.`
`4`	`4`
`5`	`5`	`using System.Collections.Generic;`
	`6`	`+using System.Reactive.Concurrency;`
`6`	`7`	`using System.Reactive.Disposables;`
`7`	`8`	`using System.Threading;`
`8`	`9`	`using System.Threading.Tasks;`
`@@ -629,7 +630,7 @@ private void OnCompletedTask(TSource value, Task<TCollection> task)`
`629`	`630`	`{`
`630`	`631`	`lock (_gate)`
`631`	`632`	`{`
`632`		`- ForwardOnError(task.Exception.InnerException);`
	`633`	`+ ForwardOnError(TaskHelpers.GetSingleException(task));`
`633`	`634`	`}`
`634`	`635`
`635`	`636`	`break;`
`@@ -786,7 +787,7 @@ private void OnCompletedTask(TSource value, int index, Task<TCollection> task)`
`786`	`787`	`{`
`787`	`788`	`lock (_gate)`
`788`	`789`	`{`
`789`		`- ForwardOnError(task.Exception.InnerException);`
	`790`	`+ ForwardOnError(TaskHelpers.GetSingleException(task));`
`790`	`791`	`}`
`791`	`792`
`792`	`793`	`break;`
`@@ -1532,7 +1533,7 @@ public override void OnNext(TSource value)`
`1532`	`1533`	`}`
`1533`	`1534`	`else`
`1534`	`1535`	`{`
`1535`		`- task.ContinueWith((closureTask, thisObject) => ((_)thisObject).OnCompletedTask(closureTask), this, _cts.Token);`
	`1536`	`+ task.ContinueWith((closureTask, thisObject) => ((_)thisObject!).OnCompletedTask(closureTask), this, _cts.Token);`
`1536`	`1537`	`}`
`1537`	`1538`	`}`
`1538`	`1539`
`@@ -1555,7 +1556,7 @@ private void OnCompletedTask(Task<TResult> task)`
`1555`	`1556`	`{`
`1556`	`1557`	`lock (_gate)`
`1557`	`1558`	`{`
`1558`		`- ForwardOnError(task.Exception.InnerException);`
	`1559`	`+ ForwardOnError(TaskHelpers.GetSingleException(task));`
`1559`	`1560`	`}`
`1560`	`1561`
`1561`	`1562`	`break;`
`@@ -1667,7 +1668,7 @@ public override void OnNext(TSource value)`
`1667`	`1668`	`}`
`1668`	`1669`	`else`
`1669`	`1670`	`{`
`1670`		`- task.ContinueWith((closureTask, thisObject) => ((_)thisObject).OnCompletedTask(closureTask), this, _cts.Token);`
	`1671`	`+ task.ContinueWith((closureTask, thisObject) => ((_)thisObject!).OnCompletedTask(closureTask), this, _cts.Token);`
`1671`	`1672`	`}`
`1672`	`1673`	`}`
`1673`	`1674`
`@@ -1690,7 +1691,7 @@ private void OnCompletedTask(Task<TResult> task)`
`1690`	`1691`	`{`
`1691`	`1692`	`lock (_gate)`
`1692`	`1693`	`{`
`1693`		`- ForwardOnError(task.Exception.InnerException);`
	`1694`	`+ ForwardOnError(TaskHelpers.GetSingleException(task));`
`1694`	`1695`	`}`
`1695`	`1696`
`1696`	`1697`	`break;`