rem braces (#385)

bitfaster · Alex Peck · web-flow · commit 28002e5cfed0 · 2023-08-23T21:21:03.000-07:00
* rem braces

* rem braces

* excl builder

* rem exlc

---------

Co-authored-by: Alex Peck &lt;alexpeck@microsoft.com&gt;
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryAsyncCache.cs
@@ -26,9 +26,7 @@ public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>
         public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)
         {
             if (cache == null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
 
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryCache.cs
@@ -24,9 +24,7 @@ public sealed class AtomicFactoryCache<K, V> : ICache<K, V>
         public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)
         {
             if (cache == null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
 
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
@@ -26,9 +26,7 @@ public sealed class AtomicFactoryScopedAsyncCache<K, V> : IScopedAsyncCache<K, V
         public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> cache)
         {
             if (cache == null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
             if (cache.Events.HasValue)
@@ -106,9 +104,7 @@ private async ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TFactory>(K key, TFacto
                 spinwait.SpinOnce();
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
-                {
                     Throw.ScopedRetryFailure();
-                }
             }
         }
 
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
@@ -25,9 +25,7 @@ public sealed class AtomicFactoryScopedCache<K, V> : IScopedCache<K, V> where V
         public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)
         {
             if (cache == null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
             
@@ -106,9 +104,7 @@ private Lifetime<V> ScopedGetOrAdd<TFactory>(K key, TFactory valueFactory) where
                 spinwait.SpinOnce();
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
-                {
                     Throw.ScopedRetryFailure();
-                }
             }
         }
 
diff --git a/BitFaster.Caching/Buffers/MpmcBoundedBuffer.cs b/BitFaster.Caching/Buffers/MpmcBoundedBuffer.cs
@@ -24,9 +24,7 @@ public sealed class MpmcBoundedBuffer<T>
         public MpmcBoundedBuffer(int boundedLength)
         {
             if (boundedLength < 0)
-            {
                 Throw.ArgOutOfRange(nameof(boundedLength));
-            }
 
             // must be power of 2 to use & slotsMask instead of %
             boundedLength = BitOps.CeilingPowerOfTwo(boundedLength);
diff --git a/BitFaster.Caching/Buffers/MpscBoundedBuffer.cs b/BitFaster.Caching/Buffers/MpscBoundedBuffer.cs
@@ -26,9 +26,7 @@ public sealed class MpscBoundedBuffer<T> where T : class
         public MpscBoundedBuffer(int boundedLength)
         {
             if (boundedLength < 0)
-            {
                 Throw.ArgOutOfRange(nameof(boundedLength));
-            }
 
             // must be power of 2 to use & slotsMask instead of %
             boundedLength = BitOps.CeilingPowerOfTwo(boundedLength);
diff --git a/BitFaster.Caching/CacheDebugView.cs b/BitFaster.Caching/CacheDebugView.cs
@@ -12,9 +12,7 @@ internal class CacheDebugView<K, V>
         public CacheDebugView(ICache<K, V> cache)
         {
             if (cache is null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
         }
diff --git a/BitFaster.Caching/Lfu/LfuCapacityPartition.cs b/BitFaster.Caching/Lfu/LfuCapacityPartition.cs
@@ -121,9 +121,7 @@ private double Clamp(double input, double min, double max)
         private static (int window, int mainProtected, int mainProbation) ComputeQueueCapacity(int capacity, double mainPercentage)
         {
             if (capacity < 3)
-            {
                 Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
-            }
 
             int window = capacity - (int)(mainPercentage * capacity);
             int mainProtected = (int)(0.8 * (capacity - window));
diff --git a/BitFaster.Caching/Lfu/LfuNodeList.cs b/BitFaster.Caching/Lfu/LfuNodeList.cs
@@ -124,28 +124,20 @@ IEnumerator IEnumerable.GetEnumerator()
         internal static void ValidateNewNode(LfuNode<K, V> node)
         {
             if (node == null)
-            {
                 Throw.ArgNull(ExceptionArgument.node);
-            }
 
             if (node.list != null)
-            {
                 Throw.InvalidOp("Node is already attached to a list.");
-            }
         }
 
         [ExcludeFromCodeCoverage]
         internal void ValidateNode(LfuNode<K, V> node)
         {
             if (node == null)
-            {
                 Throw.ArgNull(ExceptionArgument.node);
-            }
 
             if (node.list != this)
-            {
                 Throw.InvalidOp("Node is already attached to a different list.");
-            }
         }
 #endif
 
@@ -172,9 +164,7 @@ object IEnumerator.Current
                 get
                 {
                     if (index == 0 || (index == list.Count + 1))
-                    {
                         Throw.InvalidOp("Out of bounds");
-                    }
 
                     return Current;
                 }
diff --git a/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs b/BitFaster.Caching/Lru/CapacityPartitionExtensions.cs
@@ -15,19 +15,13 @@ public static class CapacityPartitionExtensions
         public static void Validate(this ICapacityPartition capacity)
         {
             if (capacity.Cold < 1)
-            { 
                 Throw.ArgOutOfRange(nameof(capacity.Cold));
-            }
 
             if (capacity.Warm < 1)
-            {
                 Throw.ArgOutOfRange(nameof(capacity.Warm));
-            }
 
             if (capacity.Hot < 1)
-            {
                 Throw.ArgOutOfRange(nameof(capacity.Hot));
-            }
         }
     }
 }
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -46,14 +46,10 @@ public ClassicLru(int capacity)
         public ClassicLru(int concurrencyLevel, int capacity, IEqualityComparer<K> comparer)
         {
             if (capacity < 3)
-            {
                 Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
-            }
 
             if (comparer == null)
-            {
                 Throw.ArgNull(ExceptionArgument.comparer);
-            }
 
             this.capacity = capacity;
             this.dictionary = new ConcurrentDictionary<K, LinkedListNode<LruItem>>(concurrencyLevel, this.capacity + 1, comparer);
diff --git a/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs b/BitFaster.Caching/Lru/ConcurrentLruBuilder.cs
@@ -1,4 +1,5 @@
 ﻿
+using System.Diagnostics.CodeAnalysis;
 using BitFaster.Caching.Lru.Builder;
 
 namespace BitFaster.Caching.Lru
diff --git a/BitFaster.Caching/Lru/ConcurrentLruCore.cs b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
@@ -76,14 +76,10 @@ public ConcurrentLruCore(
             T telemetryPolicy)
         {
             if (capacity == null)
-            {
                 Throw.ArgNull(ExceptionArgument.capacity);
-            }
 
             if (comparer == null)
-            {
                 Throw.ArgNull(ExceptionArgument.comparer);
-            }
 
             capacity.Validate();
             this.capacity = capacity;
@@ -418,9 +414,7 @@ public void Trim(int itemCount)
             int capacity = this.Capacity;
 
             if (itemCount < 1 || itemCount > capacity)
-            {
                 Throw.ArgOutOfRange(nameof(itemCount), "itemCount must be greater than or equal to one, and less than the capacity of the cache.");
-            }
 
             // clamp itemCount to number of items actually in the cache
             itemCount = Math.Min(itemCount, this.HotCount + this.WarmCount + this.ColdCount);
diff --git a/BitFaster.Caching/Lru/EqualCapacityPartition.cs b/BitFaster.Caching/Lru/EqualCapacityPartition.cs
@@ -37,9 +37,7 @@ public EqualCapacityPartition(int totalCapacity)
         private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity)
         {
             if (capacity < 3)
-            {
                 Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
-            }
 
             int hotCapacity = capacity / 3;
             int warmCapacity = capacity / 3;
diff --git a/BitFaster.Caching/Lru/FavorWarmPartition.cs b/BitFaster.Caching/Lru/FavorWarmPartition.cs
@@ -54,14 +54,10 @@ public FavorWarmPartition(int totalCapacity, double warmRatio)
         private static (int hot, int warm, int cold) ComputeQueueCapacity(int capacity, double warmRatio)
         {
             if (capacity < 3)
-            {
                 Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");
-            }
 
             if (warmRatio <= 0.0 || warmRatio >= 1.0)
-            {
                 Throw.ArgOutOfRange(nameof(warmRatio), "warmRatio must be between 0.0 and 1.0");
-            }
 
             int warm2 = (int)(capacity * warmRatio);
             int hot2 = (capacity - warm2) / 2;
diff --git a/BitFaster.Caching/Lru/StopwatchTickConverter.cs b/BitFaster.Caching/Lru/StopwatchTickConverter.cs
@@ -12,13 +12,10 @@ internal static long ToTicks(TimeSpan timespan)
         {
             // mac adjustment factor is 100, giving lowest maximum TTL on mac platform - use same upper limit on all platforms for consistency
             // this also avoids overflow when multipling long.MaxValue by 1.0
-            double maxTicks = long.MaxValue * 0.01d;
+            const double maxTicks = long.MaxValue * 0.01d;
 
             if (timespan <= TimeSpan.Zero || timespan.Ticks >= maxTicks)
-            {
-                TimeSpan maxRepresentable = TimeSpan.FromTicks((long)maxTicks);
-                Throw.ArgOutOfRange(nameof(timespan), $"Value must be greater than zero and less than {maxRepresentable}");
-            }
+                Throw.ArgOutOfRange(nameof(timespan), $"Value must be greater than zero and less than {TimeSpan.FromTicks((long)maxTicks)}");
 
             return (long)(timespan.Ticks * stopwatchAdjustmentFactor);
         }
diff --git a/BitFaster.Caching/Lru/TlruTickCount64Policy.cs b/BitFaster.Caching/Lru/TlruTickCount64Policy.cs
@@ -31,9 +31,7 @@ public TLruLongTicksPolicy(TimeSpan timeToLive)
         {
             TimeSpan maxRepresentable = TimeSpan.FromTicks(9223372036854769664);
             if (timeToLive <= TimeSpan.Zero || timeToLive > maxRepresentable)
-            {
                 Throw.ArgOutOfRange(nameof(timeToLive), $"Value must greater than zero and less than {maxRepresentable}");
-            }
 
             this.timeToLive = (long)timeToLive.TotalMilliseconds;
         }
diff --git a/BitFaster.Caching/Scoped.cs b/BitFaster.Caching/Scoped.cs
@@ -69,9 +69,7 @@ public bool TryCreateLifetime(out Lifetime<T> lifetime)
         public Lifetime<T> CreateLifetime()
         {
             if (!TryCreateLifetime(out var lifetime))
-            {
                 Throw.Disposed<T>();
-            }
 
             return lifetime;
         }
@@ -126,9 +124,7 @@ internal class ScopedDebugView
             public ScopedDebugView(Scoped<T> scoped)
             {
                 if (scoped is null)
-                {
                     Throw.ArgNull(ExceptionArgument.scoped);
-                }
 
                 this.scoped = scoped;
             }
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -28,9 +28,7 @@ public sealed class ScopedAsyncCache<K, V> : IScopedAsyncCache<K, V> where V : I
         public ScopedAsyncCache(IAsyncCache<K, Scoped<V>> cache)
         {
             if (cache == null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
         }
@@ -79,9 +77,7 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scop
                 spinwait.SpinOnce();
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
-                {
                     Throw.ScopedRetryFailure();
-                }
             }
         }
 
@@ -112,9 +108,7 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TArg>(K key, Func<K, TAr
                 spinwait.SpinOnce();
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
-                {
                     Throw.ScopedRetryFailure();
-                }
             }
         }
 #endif
diff --git a/BitFaster.Caching/ScopedAsyncCacheDebugView.cs b/BitFaster.Caching/ScopedAsyncCacheDebugView.cs
@@ -12,9 +12,7 @@ internal class ScopedAsyncCacheDebugView<K, V> where V : IDisposable
         public ScopedAsyncCacheDebugView(IScopedAsyncCache<K, V> cache)
         {
             if (cache is null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
         }
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs
@@ -26,9 +26,7 @@ public sealed class ScopedCache<K, V> : IScopedCache<K, V> where V : IDisposable
         public ScopedCache(ICache<K, Scoped<V>> cache)
         {
             if (cache == null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
         }
@@ -98,9 +96,7 @@ private Lifetime<V> ScopedGetOrAdd<TFactory>(K key, TFactory valueFactory) where
                 spinwait.SpinOnce();
 
                 if (c++ > ScopedCacheDefaults.MaxRetry)
-                {
                     Throw.ScopedRetryFailure();
-                }
             }
         }
 
diff --git a/BitFaster.Caching/ScopedCacheDebugView.cs b/BitFaster.Caching/ScopedCacheDebugView.cs
@@ -12,9 +12,7 @@ internal class ScopedCacheDebugView<K, V> where V : IDisposable
         public ScopedCacheDebugView(IScopedCache<K, V> cache)
         {
             if (cache is null)
-            {
                 Throw.ArgNull(ExceptionArgument.cache);
-            }
 
             this.cache = cache;
         }

Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,7 @@ public sealed class AtomicFactoryAsyncCache<K, V> : IAsyncCache<K, V>`
`26`	`26`	`public AtomicFactoryAsyncCache(ICache<K, AsyncAtomicFactory<K, V>> cache)`
`27`	`27`	`{`
`28`	`28`	`if (cache == null)`
`29`		`- {`
`30`	`29`	`Throw.ArgNull(ExceptionArgument.cache);`
`31`		`- }`
`32`	`30`
`33`	`31`	`this.cache = cache;`
`34`	`32`
Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,7 @@ public sealed class AtomicFactoryCache<K, V> : ICache<K, V>`
`24`	`24`	`public AtomicFactoryCache(ICache<K, AtomicFactory<K, V>> cache)`
`25`	`25`	`{`
`26`	`26`	`if (cache == null)`
`27`		`- {`
`28`	`27`	`Throw.ArgNull(ExceptionArgument.cache);`
`29`		`- }`
`30`	`28`
`31`	`29`	`this.cache = cache;`
`32`	`30`
Original file line number	Diff line number	Diff line change
`@@ -25,9 +25,7 @@ public sealed class AtomicFactoryScopedCache<K, V> : IScopedCache<K, V> where V`
`25`	`25`	`public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)`
`26`	`26`	`{`
`27`	`27`	`if (cache == null)`
`28`		`- {`
`29`	`28`	`Throw.ArgNull(ExceptionArgument.cache);`
`30`		`- }`
`31`	`29`
`32`	`30`	`this.cache = cache;`
`33`	`31`
`@@ -106,9 +104,7 @@ private Lifetime<V> ScopedGetOrAdd<TFactory>(K key, TFactory valueFactory) where`
`106`	`104`	`spinwait.SpinOnce();`
`107`	`105`
`108`	`106`	`if (c++ > ScopedCacheDefaults.MaxRetry)`
`109`		`- {`
`110`	`107`	`Throw.ScopedRetryFailure();`
`111`		`- }`
`112`	`108`	`}`
`113`	`109`	`}`
`114`	`110`
Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,7 @@ public sealed class MpmcBoundedBuffer<T>`
`24`	`24`	`public MpmcBoundedBuffer(int boundedLength)`
`25`	`25`	`{`
`26`	`26`	`if (boundedLength < 0)`
`27`		`- {`
`28`	`27`	`Throw.ArgOutOfRange(nameof(boundedLength));`
`29`		`- }`
`30`	`28`
`31`	`29`	`// must be power of 2 to use & slotsMask instead of %`
`32`	`30`	`boundedLength = BitOps.CeilingPowerOfTwo(boundedLength);`
Original file line number	Diff line number	Diff line change
`@@ -26,9 +26,7 @@ public sealed class MpscBoundedBuffer<T> where T : class`
`26`	`26`	`public MpscBoundedBuffer(int boundedLength)`
`27`	`27`	`{`
`28`	`28`	`if (boundedLength < 0)`
`29`		`- {`
`30`	`29`	`Throw.ArgOutOfRange(nameof(boundedLength));`
`31`		`- }`
`32`	`30`
`33`	`31`	`// must be power of 2 to use & slotsMask instead of %`
`34`	`32`	`boundedLength = BitOps.CeilingPowerOfTwo(boundedLength);`
Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,7 @@ internal class CacheDebugView<K, V>`
`12`	`12`	`public CacheDebugView(ICache<K, V> cache)`
`13`	`13`	`{`
`14`	`14`	`if (cache is null)`
`15`		`- {`
`16`	`15`	`Throw.ArgNull(ExceptionArgument.cache);`
`17`		`- }`
`18`	`16`
`19`	`17`	`this.cache = cache;`
`20`	`18`	`}`
Original file line number	Diff line number	Diff line change
`@@ -121,9 +121,7 @@ private double Clamp(double input, double min, double max)`
`121`	`121`	`private static (int window, int mainProtected, int mainProbation) ComputeQueueCapacity(int capacity, double mainPercentage)`
`122`	`122`	`{`
`123`	`123`	`if (capacity < 3)`
`124`		`- {`
`125`	`124`	`Throw.ArgOutOfRange(nameof(capacity), "Capacity must be greater than or equal to 3.");`
`126`		`- }`
`127`	`125`
`128`	`126`	`int window = capacity - (int)(mainPercentage * capacity);`
`129`	`127`	`int mainProtected = (int)(0.8 * (capacity - window));`
Original file line number	Diff line number	Diff line change
`@@ -124,28 +124,20 @@ IEnumerator IEnumerable.GetEnumerator()`
`124`	`124`	`internal static void ValidateNewNode(LfuNode<K, V> node)`
`125`	`125`	`{`
`126`	`126`	`if (node == null)`
`127`		`- {`
`128`	`127`	`Throw.ArgNull(ExceptionArgument.node);`
`129`		`- }`
`130`	`128`
`131`	`129`	`if (node.list != null)`
`132`		`- {`
`133`	`130`	`Throw.InvalidOp("Node is already attached to a list.");`
`134`		`- }`
`135`	`131`	`}`
`136`	`132`
`137`	`133`	`[ExcludeFromCodeCoverage]`
`138`	`134`	`internal void ValidateNode(LfuNode<K, V> node)`
`139`	`135`	`{`
`140`	`136`	`if (node == null)`
`141`		`- {`
`142`	`137`	`Throw.ArgNull(ExceptionArgument.node);`
`143`		`- }`
`144`	`138`
`145`	`139`	`if (node.list != this)`
`146`		`- {`
`147`	`140`	`Throw.InvalidOp("Node is already attached to a different list.");`
`148`		`- }`
`149`	`141`	`}`
`150`	`142`	`#endif`
`151`	`143`
`@@ -172,9 +164,7 @@ object IEnumerator.Current`
`172`	`164`	`get`
`173`	`165`	`{`
`174`	`166`	`if (index == 0 \|\| (index == list.Count + 1))`
`175`		`- {`
`176`	`167`	`Throw.InvalidOp("Out of bounds");`
`177`		`- }`
`178`	`168`
`179`	`169`	`return Current;`
`180`	`170`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,19 +15,13 @@ public static class CapacityPartitionExtensions`
`15`	`15`	`public static void Validate(this ICapacityPartition capacity)`
`16`	`16`	`{`
`17`	`17`	`if (capacity.Cold < 1)`
`18`		`- {`
`19`	`18`	`Throw.ArgOutOfRange(nameof(capacity.Cold));`
`20`		`- }`
`21`	`19`
`22`	`20`	`if (capacity.Warm < 1)`
`23`		`- {`
`24`	`21`	`Throw.ArgOutOfRange(nameof(capacity.Warm));`
`25`		`- }`
`26`	`22`
`27`	`23`	`if (capacity.Hot < 1)`
`28`		`- {`
`29`	`24`	`Throw.ArgOutOfRange(nameof(capacity.Hot));`
`30`		`- }`
`31`	`25`	`}`
`32`	`26`	`}`
`33`	`27`	`}`