Merge pull request #740 from danielcweber/RemoveRedundanciesInSymbolDeclarations

danielcweber · web-flow · commit 3af72770f949 · 2018-07-03T14:36:20.000+02:00
Remove redundancies in symbol declarations
diff --git a/Rx.NET/Source/Directory.build.props b/Rx.NET/Source/Directory.build.props
@@ -25,6 +25,7 @@
   </PropertyGroup>
   
   <ItemGroup Condition="'$(IsTestProject)' != 'true' and '$(SourceLinkEnabled)' != 'false'">
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.1" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0-beta-62925-02" PrivateAssets="All"/>
   </ItemGroup>   
   
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/HistoricalScheduler.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/HistoricalScheduler.cs
@@ -75,7 +75,6 @@ public class HistoricalScheduler : HistoricalSchedulerBase
         /// Creates a new historical scheduler with the minimum value of <see cref="DateTimeOffset"/> as the initial clock value.
         /// </summary>
         public HistoricalScheduler()
-            : base()
         {
         }
 
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/LocalScheduler.TimerQueue.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/LocalScheduler.TimerQueue.cs
@@ -333,16 +333,15 @@ private static void UpdateLongTermProcessingTimer()
                 var dueCapped = TimeSpan.FromTicks(Math.Min(dueEarly.Ticks, MAXSUPPORTEDTIMER.Ticks));
 
                 _nextLongTermWorkItem = next;
-                _nextLongTermTimer.Disposable = ConcurrencyAbstractionLayer.Current.StartTimer(_ => EvaluateLongTermQueue(_), null, dueCapped);
+                _nextLongTermTimer.Disposable = ConcurrencyAbstractionLayer.Current.StartTimer(_ => EvaluateLongTermQueue(), null, dueCapped);
             }
         }
 
         /// <summary>
         /// Evaluates the long term queue, transitioning short term work to the short term list,
         /// and adjusting the new long term processing timer accordingly.
         /// </summary>
-        /// <param name="state">Ignored.</param>
-        private static void EvaluateLongTermQueue(object state)
+        private static void EvaluateLongTermQueue()
         {
             lock (_staticGate)
             {
@@ -408,7 +407,7 @@ internal void SystemClockChanged(object sender, SystemClockChangedEventArgs args
                     // method to create a new timer for the new first long term item.
                     //
                     _nextLongTermWorkItem = null;
-                    EvaluateLongTermQueue(null);
+                    EvaluateLongTermQueue();
                 }
             }
         }
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Recursive.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/Scheduler.Recursive.cs
@@ -171,7 +171,7 @@ private static IDisposable InvokeRec3<TState>(IScheduler scheduler, (TState stat
             return recursiveInvoker;
         }
 
-        private abstract class InvokeRecBaseState<TState> : IDisposable
+        private abstract class InvokeRecBaseState : IDisposable
         {
             protected readonly IScheduler Scheduler;
 
@@ -190,7 +190,7 @@ public void Dispose()
 
         }
 
-        private sealed class InvokeRec1State<TState> : InvokeRecBaseState<TState>
+        private sealed class InvokeRec1State<TState> : InvokeRecBaseState
         {
             private readonly Action<TState, Action<TState>> _action;
             private readonly Action<TState> _recurseCallback;
@@ -219,7 +219,7 @@ internal void InvokeFirst(TState state)
             }
         }
 
-        private sealed class InvokeRec2State<TState> : InvokeRecBaseState<TState>
+        private sealed class InvokeRec2State<TState> : InvokeRecBaseState
         {
             private readonly Action<TState, Action<TState, TimeSpan>> _action;
             private readonly Action<TState, TimeSpan> _recurseCallback;
@@ -247,7 +247,7 @@ internal void InvokeFirst(TState state)
             }
         }
 
-        private sealed class InvokeRec3State<TState> : InvokeRecBaseState<TState>
+        private sealed class InvokeRec3State<TState> : InvokeRecBaseState
         {
             private readonly Action<TState, Action<TState, DateTimeOffset>> _action;
             private readonly Action<TState, DateTimeOffset> _recurseCallback;
diff --git a/Rx.NET/Source/src/System.Reactive/Concurrency/VirtualTimeScheduler.cs b/Rx.NET/Source/src/System.Reactive/Concurrency/VirtualTimeScheduler.cs
@@ -363,7 +363,6 @@ public abstract class VirtualTimeScheduler<TAbsolute, TRelative> : VirtualTimeSc
         /// Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value.
         /// </summary>
         protected VirtualTimeScheduler()
-            : base()
         {
         }
 
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs b/Rx.NET/Source/src/System.Reactive/Internal/ScheduledObserver.cs
@@ -100,10 +100,8 @@ private void Dispatch(ICancelable cancel)
                     }
                     catch
                     {
-                        var nop = default(T);
-                        while (_queue.TryDequeue(out nop))
+                        while (_queue.TryDequeue(out _))
                         {
-                            ;
                         }
 
                         throw;
@@ -287,10 +285,8 @@ private void Run(object state, Action<object> recurse)
             {
                 Interlocked.Exchange(ref _state, FAULTED);
 
-                var nop = default(T);
-                while (_queue.TryDequeue(out nop))
+                while (_queue.TryDequeue(out _))
                 {
-                    ;
                 }
 
                 throw;
diff --git a/Rx.NET/Source/src/System.Reactive/Internal/SystemClock.cs b/Rx.NET/Source/src/System.Reactive/Internal/SystemClock.cs
@@ -123,7 +123,7 @@ private static void CollectHandlers()
 
                 foreach (var handler in _systemClockChanged)
                 {
-                    if (!handler.TryGetTarget(out var scheduler))
+                    if (!handler.TryGetTarget(out _))
                     {
                         if (remove == null)
                         {
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable.Creation.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable.Creation.cs
@@ -407,7 +407,7 @@ public static IObservable<TResult> Never<TResult>(TResult witness)
         /// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero. -or- <paramref name="start"/> + <paramref name="count"/> - 1 is larger than <see cref="int.MaxValue"/>.</exception>
         public static IObservable<int> Range(int start, int count)
         {
-            var max = ((long)start) + count - 1;
+            var max = (long)start + count - 1;
             if (count < 0 || max > int.MaxValue)
             {
                 throw new ArgumentOutOfRangeException(nameof(count));
@@ -427,7 +427,7 @@ public static IObservable<int> Range(int start, int count)
         /// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is null.</exception>
         public static IObservable<int> Range(int start, int count, IScheduler scheduler)
         {
-            var max = ((long)start) + count - 1;
+            var max = (long)start + count - 1;
             if (count < 0 || max > int.MaxValue)
             {
                 throw new ArgumentOutOfRangeException(nameof(count));
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/FirstLastBlocking.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/FirstLastBlocking.cs
@@ -52,8 +52,6 @@ public virtual void OnError(Exception error)
 
     internal sealed class FirstBlocking<T> : BaseBlocking<T>
     {
-        internal FirstBlocking() : base() { }
-
         public override void OnCompleted()
         {
             Unblock();
@@ -86,8 +84,6 @@ public override void OnNext(T value)
 
     internal sealed class LastBlocking<T> : BaseBlocking<T>
     {
-        internal LastBlocking() : base() { }
-
         public override void OnCompleted()
         {
             Unblock();
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/GroupByUntil.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/GroupByUntil.cs
@@ -350,7 +350,7 @@ public TValue GetOrAdd(TKey key, Func<TValue> valueFactory, out bool added)
 
         public bool Remove(TKey key)
         {
-            return _map.TryRemove(key, out var value);
+            return _map.TryRemove(key, out _);
         }
     }
 }
diff --git a/Rx.NET/Source/src/System.Reactive/Linq/Observable/PushToPullAdapter.cs b/Rx.NET/Source/src/System.Reactive/Linq/Observable/PushToPullAdapter.cs
@@ -29,7 +29,7 @@ public IEnumerator<TResult> GetEnumerator()
         protected abstract PushToPullSink<TSource, TResult> Run();
     }
 
-    internal abstract class PushToPullSink<TSource, TResult> : IObserver<TSource>, IEnumerator<TResult>, IDisposable
+    internal abstract class PushToPullSink<TSource, TResult> : IObserver<TSource>, IEnumerator<TResult>
     {
         private IDisposable _upstream;
 
diff --git a/Rx.NET/Source/src/System.Reactive/Runtime/CompilerServices/AsyncMethodBuilderAttribute.cs b/Rx.NET/Source/src/System.Reactive/Runtime/CompilerServices/AsyncMethodBuilderAttribute.cs
diff --git a/Rx.NET/Source/src/System.Reactive/Subjects/AsyncSubject.cs b/Rx.NET/Source/src/System.Reactive/Subjects/AsyncSubject.cs
@@ -13,7 +13,7 @@ namespace System.Reactive.Subjects
     /// The last value before the OnCompleted notification, or the error received through OnError, is sent to all subscribed observers.
     /// </summary>
     /// <typeparam name="T">The type of the elements processed by the subject.</typeparam>
-    public sealed class AsyncSubject<T> : SubjectBase<T>, IDisposable, INotifyCompletion
+    public sealed class AsyncSubject<T> : SubjectBase<T>, INotifyCompletion
     {
         #region Fields
 
@@ -146,7 +146,6 @@ public override void OnError(Exception error)
                 _exception = error;
                 if (Interlocked.CompareExchange(ref _observers, TERMINATED, observers) == observers)
                 {
-                    var ex = _exception;
                     foreach (var o in observers)
                     {
                         if (!o.IsDisposed())
diff --git a/Rx.NET/Source/src/System.Reactive/Subjects/BehaviorSubject.cs b/Rx.NET/Source/src/System.Reactive/Subjects/BehaviorSubject.cs
@@ -11,7 +11,7 @@ namespace System.Reactive.Subjects
     /// Observers can subscribe to the subject to receive the last (or initial) value and all subsequent notifications.
     /// </summary>
     /// <typeparam name="T">The type of the elements processed by the subject.</typeparam>
-    public sealed class BehaviorSubject<T> : SubjectBase<T>, IDisposable
+    public sealed class BehaviorSubject<T> : SubjectBase<T>
     {
         #region Fields
 
diff --git a/Rx.NET/Source/src/System.Reactive/Subjects/ReplaySubject.cs b/Rx.NET/Source/src/System.Reactive/Subjects/ReplaySubject.cs
@@ -14,7 +14,7 @@ namespace System.Reactive.Subjects
     /// Each notification is broadcasted to all subscribed and future observers, subject to buffer trimming policies.
     /// </summary>
     /// <typeparam name="T">The type of the elements processed by the subject.</typeparam>
-    public sealed class ReplaySubject<T> : SubjectBase<T>, IDisposable
+    public sealed class ReplaySubject<T> : SubjectBase<T>
     {
         #region Fields
 
@@ -656,7 +656,6 @@ private abstract class ReplayManyBase : ReplayBufferBase
             protected readonly Queue<T> _queue;
 
             protected ReplayManyBase(int queueSize)
-                : base()
             {
                 _queue = new Queue<T>(Math.Min(queueSize, 64));
             }
diff --git a/Rx.NET/Source/src/System.Reactive/Subjects/Subject.cs b/Rx.NET/Source/src/System.Reactive/Subjects/Subject.cs
@@ -12,7 +12,7 @@ namespace System.Reactive.Subjects
     /// Each notification is broadcasted to all subscribed observers.
     /// </summary>
     /// <typeparam name="T">The type of the elements processed by the subject.</typeparam>
-    public sealed class Subject<T> : SubjectBase<T>, IDisposable
+    public sealed class Subject<T> : SubjectBase<T>
     {
         #region Fields
 
diff --git a/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.approved.txt b/Rx.NET/Source/tests/Tests.System.Reactive.ApiApprovals/Api/ApiApprovalTests.Core.approved.txt
@@ -83,6 +83,7 @@ namespace System.Reactive
         TResult OnError(System.Exception exception);
         TResult OnNext(TValue value);
     }
+    [System.Runtime.CompilerServices.AsyncMethodBuilderAttribute(typeof(System.Runtime.CompilerServices.TaskObservableMethodBuilder<>))]
     public interface ITaskObservable<out T> : System.IObservable<T>
     {
         System.Reactive.ITaskObservableAwaiter<T> GetAwaiter();
@@ -2406,7 +2407,7 @@ namespace System.Reactive.PlatformServices
 }
 namespace System.Reactive.Subjects
 {
-    public sealed class AsyncSubject<T> : System.Reactive.Subjects.SubjectBase<T>, System.IDisposable, System.Runtime.CompilerServices.INotifyCompletion
+    public sealed class AsyncSubject<T> : System.Reactive.Subjects.SubjectBase<T>, System.Runtime.CompilerServices.INotifyCompletion
     {
         public AsyncSubject() { }
         public override bool HasObservers { get; }
@@ -2421,7 +2422,7 @@ namespace System.Reactive.Subjects
         public override void OnNext(T value) { }
         public override System.IDisposable Subscribe(System.IObserver<T> observer) { }
     }
-    public sealed class BehaviorSubject<T> : System.Reactive.Subjects.SubjectBase<T>, System.IDisposable
+    public sealed class BehaviorSubject<T> : System.Reactive.Subjects.SubjectBase<T>
     {
         public BehaviorSubject(T value) { }
         public override bool HasObservers { get; }
@@ -2440,7 +2441,7 @@ namespace System.Reactive.Subjects
     }
     public interface ISubject<T> : System.IObservable<T>, System.IObserver<T>, System.Reactive.Subjects.ISubject<T, T> { }
     public interface ISubject<in TSource, out TResult> : System.IObservable<TResult>, System.IObserver<TSource> { }
-    public sealed class ReplaySubject<T> : System.Reactive.Subjects.SubjectBase<T>, System.IDisposable
+    public sealed class ReplaySubject<T> : System.Reactive.Subjects.SubjectBase<T>
     {
         public ReplaySubject() { }
         public ReplaySubject(System.Reactive.Concurrency.IScheduler scheduler) { }
@@ -2467,7 +2468,7 @@ namespace System.Reactive.Subjects
         public static System.Reactive.Subjects.ISubject<TSource, TResult> Synchronize<TSource, TResult>(System.Reactive.Subjects.ISubject<TSource, TResult> subject, System.Reactive.Concurrency.IScheduler scheduler) { }
         public static System.Reactive.Subjects.ISubject<TSource> Synchronize<TSource>(System.Reactive.Subjects.ISubject<TSource> subject, System.Reactive.Concurrency.IScheduler scheduler) { }
     }
-    public sealed class Subject<T> : System.Reactive.Subjects.SubjectBase<T>, System.IDisposable
+    public sealed class Subject<T> : System.Reactive.Subjects.SubjectBase<T>
     {
         public Subject() { }
         public override bool HasObservers { get; }

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,6 @@ public class HistoricalScheduler : HistoricalSchedulerBase`
`75`	`75`	`/// Creates a new historical scheduler with the minimum value of <see cref="DateTimeOffset"/> as the initial clock value.`
`76`	`76`	`/// </summary>`
`77`	`77`	`public HistoricalScheduler()`
`78`		`- : base()`
`79`	`78`	`{`
`80`	`79`	`}`
`81`	`80`
Original file line number	Diff line number	Diff line change
`@@ -333,16 +333,15 @@ private static void UpdateLongTermProcessingTimer()`
`333`	`333`	`var dueCapped = TimeSpan.FromTicks(Math.Min(dueEarly.Ticks, MAXSUPPORTEDTIMER.Ticks));`
`334`	`334`
`335`	`335`	`_nextLongTermWorkItem = next;`
`336`		`- _nextLongTermTimer.Disposable = ConcurrencyAbstractionLayer.Current.StartTimer(_ => EvaluateLongTermQueue(_), null, dueCapped);`
	`336`	`+ _nextLongTermTimer.Disposable = ConcurrencyAbstractionLayer.Current.StartTimer(_ => EvaluateLongTermQueue(), null, dueCapped);`
`337`	`337`	`}`
`338`	`338`	`}`
`339`	`339`
`340`	`340`	`/// <summary>`
`341`	`341`	`/// Evaluates the long term queue, transitioning short term work to the short term list,`
`342`	`342`	`/// and adjusting the new long term processing timer accordingly.`
`343`	`343`	`/// </summary>`
`344`		`- /// <param name="state">Ignored.</param>`
`345`		`- private static void EvaluateLongTermQueue(object state)`
	`344`	`+ private static void EvaluateLongTermQueue()`
`346`	`345`	`{`
`347`	`346`	`lock (_staticGate)`
`348`	`347`	`{`
`@@ -408,7 +407,7 @@ internal void SystemClockChanged(object sender, SystemClockChangedEventArgs args`
`408`	`407`	`// method to create a new timer for the new first long term item.`
`409`	`408`	`//`
`410`	`409`	`_nextLongTermWorkItem = null;`
`411`		`- EvaluateLongTermQueue(null);`
	`410`	`+ EvaluateLongTermQueue();`
`412`	`411`	`}`
`413`	`412`	`}`
`414`	`413`	`}`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ private static IDisposable InvokeRec3<TState>(IScheduler scheduler, (TState stat`
`171`	`171`	`return recursiveInvoker;`
`172`	`172`	`}`
`173`	`173`
`174`		`- private abstract class InvokeRecBaseState<TState> : IDisposable`
	`174`	`+ private abstract class InvokeRecBaseState : IDisposable`
`175`	`175`	`{`
`176`	`176`	`protected readonly IScheduler Scheduler;`
`177`	`177`
`@@ -190,7 +190,7 @@ public void Dispose()`
`190`	`190`
`191`	`191`	`}`
`192`	`192`
`193`		`- private sealed class InvokeRec1State<TState> : InvokeRecBaseState<TState>`
	`193`	`+ private sealed class InvokeRec1State<TState> : InvokeRecBaseState`
`194`	`194`	`{`
`195`	`195`	`private readonly Action<TState, Action<TState>> _action;`
`196`	`196`	`private readonly Action<TState> _recurseCallback;`
`@@ -219,7 +219,7 @@ internal void InvokeFirst(TState state)`
`219`	`219`	`}`
`220`	`220`	`}`
`221`	`221`
`222`		`- private sealed class InvokeRec2State<TState> : InvokeRecBaseState<TState>`
	`222`	`+ private sealed class InvokeRec2State<TState> : InvokeRecBaseState`
`223`	`223`	`{`
`224`	`224`	`private readonly Action<TState, Action<TState, TimeSpan>> _action;`
`225`	`225`	`private readonly Action<TState, TimeSpan> _recurseCallback;`
`@@ -247,7 +247,7 @@ internal void InvokeFirst(TState state)`
`247`	`247`	`}`
`248`	`248`	`}`
`249`	`249`
`250`		`- private sealed class InvokeRec3State<TState> : InvokeRecBaseState<TState>`
	`250`	`+ private sealed class InvokeRec3State<TState> : InvokeRecBaseState`
`251`	`251`	`{`
`252`	`252`	`private readonly Action<TState, Action<TState, DateTimeOffset>> _action;`
`253`	`253`	`private readonly Action<TState, DateTimeOffset> _recurseCallback;`
Original file line number	Diff line number	Diff line change
`@@ -363,7 +363,6 @@ public abstract class VirtualTimeScheduler<TAbsolute, TRelative> : VirtualTimeSc`
`363`	`363`	`/// Creates a new virtual time scheduler with the default value of TAbsolute as the initial clock value.`
`364`	`364`	`/// </summary>`
`365`	`365`	`protected VirtualTimeScheduler()`
`366`		`- : base()`
`367`	`366`	`{`
`368`	`367`	`}`
`369`	`368`
Original file line number	Diff line number	Diff line change
`@@ -100,10 +100,8 @@ private void Dispatch(ICancelable cancel)`
`100`	`100`	`}`
`101`	`101`	`catch`
`102`	`102`	`{`
`103`		`- var nop = default(T);`
`104`		`- while (_queue.TryDequeue(out nop))`
	`103`	`+ while (_queue.TryDequeue(out _))`
`105`	`104`	`{`
`106`		`- ;`
`107`	`105`	`}`
`108`	`106`
`109`	`107`	`throw;`
`@@ -287,10 +285,8 @@ private void Run(object state, Action<object> recurse)`
`287`	`285`	`{`
`288`	`286`	`Interlocked.Exchange(ref _state, FAULTED);`
`289`	`287`
`290`		`- var nop = default(T);`
`291`		`- while (_queue.TryDequeue(out nop))`
	`288`	`+ while (_queue.TryDequeue(out _))`
`292`	`289`	`{`
`293`		`- ;`
`294`	`290`	`}`
`295`	`291`
`296`	`292`	`throw;`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ private static void CollectHandlers()`
`123`	`123`
`124`	`124`	`foreach (var handler in _systemClockChanged)`
`125`	`125`	`{`
`126`		`- if (!handler.TryGetTarget(out var scheduler))`
	`126`	`+ if (!handler.TryGetTarget(out _))`
`127`	`127`	`{`
`128`	`128`	`if (remove == null)`
`129`	`129`	`{`
Original file line number	Diff line number	Diff line change
`@@ -407,7 +407,7 @@ public static IObservable<TResult> Never<TResult>(TResult witness)`
`407`	`407`	`/// <exception cref="ArgumentOutOfRangeException"><paramref name="count"/> is less than zero. -or- <paramref name="start"/> + <paramref name="count"/> - 1 is larger than <see cref="int.MaxValue"/>.</exception>`
`408`	`408`	`public static IObservable<int> Range(int start, int count)`
`409`	`409`	`{`
`410`		`- var max = ((long)start) + count - 1;`
	`410`	`+ var max = (long)start + count - 1;`
`411`	`411`	`if (count < 0 \|\| max > int.MaxValue)`
`412`	`412`	`{`
`413`	`413`	`throw new ArgumentOutOfRangeException(nameof(count));`
`@@ -427,7 +427,7 @@ public static IObservable<int> Range(int start, int count)`
`427`	`427`	`/// <exception cref="ArgumentNullException"><paramref name="scheduler"/> is null.</exception>`
`428`	`428`	`public static IObservable<int> Range(int start, int count, IScheduler scheduler)`
`429`	`429`	`{`
`430`		`- var max = ((long)start) + count - 1;`
	`430`	`+ var max = (long)start + count - 1;`
`431`	`431`	`if (count < 0 \|\| max > int.MaxValue)`
`432`	`432`	`{`
`433`	`433`	`throw new ArgumentOutOfRangeException(nameof(count));`
Original file line number	Diff line number	Diff line change
`@@ -52,8 +52,6 @@ public virtual void OnError(Exception error)`
`52`	`52`
`53`	`53`	`internal sealed class FirstBlocking<T> : BaseBlocking<T>`
`54`	`54`	`{`
`55`		`- internal FirstBlocking() : base() { }`
`56`		`-`
`57`	`55`	`public override void OnCompleted()`
`58`	`56`	`{`
`59`	`57`	`Unblock();`
`@@ -86,8 +84,6 @@ public override void OnNext(T value)`
`86`	`84`
`87`	`85`	`internal sealed class LastBlocking<T> : BaseBlocking<T>`
`88`	`86`	`{`
`89`		`- internal LastBlocking() : base() { }`
`90`		`-`
`91`	`87`	`public override void OnCompleted()`
`92`	`88`	`{`
`93`	`89`	`Unblock();`
Original file line number	Diff line number	Diff line change
`@@ -350,7 +350,7 @@ public TValue GetOrAdd(TKey key, Func<TValue> valueFactory, out bool added)`
`350`	`350`
`351`	`351`	`public bool Remove(TKey key)`
`352`	`352`	`{`
`353`		`- return _map.TryRemove(key, out var value);`
	`353`	`+ return _map.TryRemove(key, out _);`
`354`	`354`	`}`
`355`	`355`	`}`
`356`	`356`	`}`