enable code analysis (#446)

bitfaster · web-flow · commit dbb6d7b85c56 · 2023-11-01T18:39:03.000-07:00
diff --git a/.editorconfig b/.editorconfig
@@ -115,9 +115,8 @@ csharp_space_between_method_call_empty_parameter_list_parentheses = false
 # Wrapping preferences
 csharp_preserve_single_line_statements = true
 csharp_preserve_single_line_blocks = true
-###############################
-# VB Coding Conventions       #
-###############################
-[*.vb]
-# Modifier preferences
-visual_basic_preferred_modifier_order = Partial,Default,Private,Protected,Public,Friend,NotOverridable,Overridable,MustOverride,Overloads,Overrides,MustInherit,NotInheritable,Static,Shared,Shadows,ReadOnly,WriteOnly,Dim,Const,WithEvents,Widening,Narrowing,Custom,Async:suggestion
+
+# code analysis
+dotnet_diagnostic.IDE0079.severity = none
+dotnet_diagnostic.CA1805.severity = none
+dotnet_diagnostic.CA1815.severity = none
diff --git a/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs b/BitFaster.Caching.UnitTests/Lfu/ConcurrentLfuTests.cs
@@ -876,10 +876,7 @@ private void VerifyHits(int iterations, int minSamples)
 
             // verify this doesn't block or throw
             var b = cache.Scheduler as BackgroundThreadScheduler;
-            if (b is not null)
-            {
-                b.Dispose();
-            }
+            b?.Dispose();
         }
 
         private void LogLru()
diff --git a/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/AsyncAtomicFactory.cs
@@ -136,6 +136,7 @@ public async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactor
                 return await synchronizedTask.ConfigureAwait(false);
             }
 
+#pragma warning disable CA2002 // Do not lock on objects with weak identity
             private Task<V> DoubleCheck(Task<V> value)
             {
                 // Fast path
@@ -155,6 +156,7 @@ private Task<V> DoubleCheck(Task<V> value)
 
                 return valueTask;
             }
+#pragma warning restore CA2002 // Do not lock on objects with weak identity
         }
     }
 }
diff --git a/BitFaster.Caching/Atomic/AtomicFactory.cs b/BitFaster.Caching/Atomic/AtomicFactory.cs
@@ -133,6 +133,7 @@ public override int GetHashCode()
             return ValueIfCreated.GetHashCode();
         }
 
+#pragma warning disable CA2002 // Do not lock on objects with weak identity
         private class Initializer
         {
             private bool isInitialized;
@@ -153,5 +154,6 @@ public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : st
                 }
             }
         }
+#pragma warning restore CA2002 // Do not lock on objects with weak identity
     }
 }
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedAsyncCache.cs
@@ -54,11 +54,13 @@ public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> c
         ///<inheritdoc/>
         public ICollection<K> Keys => AtomicEx.FilterKeys<K, ScopedAsyncAtomicFactory<K, V>>(this.cache, v => v.IsScopeCreated);
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public void Clear()
@@ -129,11 +131,13 @@ public bool TryRemove(K key)
             return this.cache.TryRemove(key);
         }
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
diff --git a/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs b/BitFaster.Caching/Atomic/AtomicFactoryScopedCache.cs
@@ -54,11 +54,13 @@ public AtomicFactoryScopedCache(ICache<K, ScopedAtomicFactory<K, V>> cache)
         ///<inheritdoc/>
         public ICollection<K> Keys => AtomicEx.FilterKeys<K, ScopedAtomicFactory<K, V>>(this.cache, v => v.IsScopeCreated);
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new ScopedAtomicFactory<K, V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public void Clear()
@@ -129,11 +131,13 @@ public bool TryRemove(K key)
             return this.cache.TryRemove(key);
         }
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new ScopedAtomicFactory<K, V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
diff --git a/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs b/BitFaster.Caching/Atomic/ScopedAsyncAtomicFactory.cs
@@ -182,6 +182,7 @@ public async ValueTask<Scoped<V>> CreateScopeAsync<TFactory>(K key, TFactory val
                 return await synchronizedTask.ConfigureAwait(false);
             }
 
+#pragma warning disable CA2002 // Do not lock on objects with weak identity
             private Task<Scoped<V>> DoubleCheck(Task<Scoped<V>> value)
             {
                 // Fast path
@@ -201,6 +202,7 @@ private Task<Scoped<V>> DoubleCheck(Task<Scoped<V>> value)
 
                 return task;
             }
+#pragma warning restore CA2002 // Do not lock on objects with weak identity
 
             // <remarks>
             // Let's say there are 2 threads, A and B:
diff --git a/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs b/BitFaster.Caching/Atomic/ScopedAtomicFactory.cs
@@ -156,6 +156,7 @@ public void Dispose()
             scope.Dispose();
         }
 
+#pragma warning disable CA2002 // Do not lock on objects with weak identity
         private class Initializer
         {
             private bool isInitialized;
@@ -196,5 +197,6 @@ public Scoped<V> TryCreateDisposedScope()
                 }
             }
         }
+#pragma warning restore CA2002 // Do not lock on objects with weak identity
     }
 }
diff --git a/BitFaster.Caching/BitFaster.Caching.csproj b/BitFaster.Caching/BitFaster.Caching.csproj
@@ -35,6 +35,13 @@
     <ContinuousIntegrationBuild>true</ContinuousIntegrationBuild>
   </PropertyGroup>
 
+  <PropertyGroup>
+    <AnalysisModePerformance>All</AnalysisModePerformance>
+    <AnalysisModeDocumentation>All</AnalysisModeDocumentation>
+    <AnalysisModeInteroperability>All</AnalysisModeInteroperability>
+    <AnalysisModeReliability>All</AnalysisModeReliability>
+  </PropertyGroup>
+
   <ItemGroup>
     <None Include="..\LICENSE">
       <Pack>True</Pack>
diff --git a/BitFaster.Caching/Lfu/CmSketchCore.cs b/BitFaster.Caching/Lfu/CmSketchCore.cs
@@ -24,8 +24,8 @@ namespace BitFaster.Caching.Lfu
     /// https://github.com/ben-manes/caffeine
     public class CmSketchCore<T, I> where I : struct, IsaProbe
     {
-        private static readonly long ResetMask = 0x7777777777777777L;
-        private static readonly long OneMask = 0x1111111111111111L;
+        private const long ResetMask = 0x7777777777777777L;
+        private const long OneMask = 0x1111111111111111L;
 
         private long[] table;
         private int sampleSize;
diff --git a/BitFaster.Caching/Lfu/LfuCapacityPartition.cs b/BitFaster.Caching/Lfu/LfuCapacityPartition.cs
@@ -113,7 +113,7 @@ private void InitializeStepSize()
             stepSize = HillClimberStepPercent;
         }
 
-        private double Clamp(double input, double min, double max)
+        private static double Clamp(double input, double min, double max)
         {
             return Math.Max(min, Math.Min(input, max));
         }
diff --git a/BitFaster.Caching/Lru/ClassicLru.cs b/BitFaster.Caching/Lru/ClassicLru.cs
@@ -202,14 +202,14 @@ public async ValueTask<V> GetOrAddAsync(K key, Func<K, Task<V>> valueFactory)
                 return value;
             }
 
-            value = await valueFactory(key);
+            value = await valueFactory(key).ConfigureAwait(false);
 
             if (TryAdd(key, value))
             {
                 return value;
             }
 
-            return await this.GetOrAddAsync(key, valueFactory);
+            return await this.GetOrAddAsync(key, valueFactory).ConfigureAwait(false);
         }
 
         /// <summary>
@@ -228,14 +228,14 @@ public async ValueTask<V> GetOrAddAsync<TArg>(K key, Func<K, TArg, Task<V>> valu
                 return value;
             }
 
-            value = await valueFactory(key, factoryArgument);
+            value = await valueFactory(key, factoryArgument).ConfigureAwait(false);
 
             if (TryAdd(key, value))
             {
                 return value;
             }
 
-            return await this.GetOrAddAsync(key, valueFactory, factoryArgument);
+            return await this.GetOrAddAsync(key, valueFactory, factoryArgument).ConfigureAwait(false);
         }
 
         /// <summary>
diff --git a/BitFaster.Caching/Lru/ConcurrentLruCore.cs b/BitFaster.Caching/Lru/ConcurrentLruCore.cs
@@ -422,7 +422,7 @@ public void AddOrUpdate(K key, V value)
         ///<inheritdoc/>
         public void Clear()
         {
-            int count = this.Count();
+            int count = this.Count;
 
             for (int i = 0; i < count; i++)
             {
diff --git a/BitFaster.Caching/Scheduler/BackgroundThreadScheduler.cs b/BitFaster.Caching/Scheduler/BackgroundThreadScheduler.cs
@@ -35,7 +35,7 @@ public sealed class BackgroundThreadScheduler : IScheduler, IDisposable
         public BackgroundThreadScheduler()
         {
             // dedicated thread
-            Task.Factory.StartNew(() => Background(), TaskCreationOptions.LongRunning);
+            Task.Factory.StartNew(() => Background(), cts.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
         }
 
         ///<inheritdoc/>
@@ -68,7 +68,7 @@ private async Task Background()
             {
                 try
                 {
-                    await semaphore.WaitAsync(cts.Token);
+                    await semaphore.WaitAsync(cts.Token).ConfigureAwait(false);
 
                     BufferStatus s;
                     do
diff --git a/BitFaster.Caching/Scheduler/ThreadPoolScheduler.cs b/BitFaster.Caching/Scheduler/ThreadPoolScheduler.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Threading;
 using System.Threading.Tasks;
 
 namespace BitFaster.Caching.Scheduler
@@ -25,7 +26,7 @@ public void Run(Action action)
         {
             count++;
             Task.Run(action)
-                .ContinueWith(t => lastException = new Optional<Exception>(t.Exception.Flatten().InnerException), TaskContinuationOptions.OnlyOnFaulted);
+                .ContinueWith(t => lastException = new Optional<Exception>(t.Exception.Flatten().InnerException), CancellationToken.None, TaskContinuationOptions.OnlyOnFaulted, TaskScheduler.Default);
         }
     }
 }
diff --git a/BitFaster.Caching/ScopedAsyncCache.cs b/BitFaster.Caching/ScopedAsyncCache.cs
@@ -48,11 +48,13 @@ public ScopedAsyncCache(IAsyncCache<K, Scoped<V>> cache)
         ///<inheritdoc/>
         public ICollection<K> Keys => this.cache.Keys;
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new Scoped<V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public void Clear()
@@ -67,7 +69,7 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync(K key, Func<K, Task<Scop
             var spinwait = new SpinWait();
             while (true)
             {
-                var scope = await cache.GetOrAddAsync(key, valueFactory);
+                var scope = await cache.GetOrAddAsync(key, valueFactory).ConfigureAwait(false);
 
                 if (scope.TryCreateLifetime(out var lifetime))
                 {
@@ -98,7 +100,7 @@ public async ValueTask<Lifetime<V>> ScopedGetOrAddAsync<TArg>(K key, Func<K, TAr
             var spinwait = new SpinWait();
             while (true)
             {
-                var scope = await cache.GetOrAddAsync(key, valueFactory, factoryArgument);
+                var scope = await cache.GetOrAddAsync(key, valueFactory, factoryArgument).ConfigureAwait(false);
 
                 if (scope.TryCreateLifetime(out var lifetime))
                 {
@@ -134,11 +136,13 @@ public bool TryRemove(K key)
             return this.cache.TryRemove(key);
         }
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new Scoped<V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()
diff --git a/BitFaster.Caching/ScopedCache.cs b/BitFaster.Caching/ScopedCache.cs
@@ -46,11 +46,13 @@ public ScopedCache(ICache<K, Scoped<V>> cache)
         ///<inheritdoc/>
         public ICollection<K> Keys => this.cache.Keys;
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public void AddOrUpdate(K key, V value)
         {
             this.cache.AddOrUpdate(key, new Scoped<V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public void Clear()
@@ -121,11 +123,13 @@ public bool TryRemove(K key)
             return this.cache.TryRemove(key);
         }
 
+#pragma warning disable CA2000 // Dispose objects before losing scope
         ///<inheritdoc/>
         public bool TryUpdate(K key, V value)
         {
             return this.cache.TryUpdate(key, new Scoped<V>(value));
         }
+#pragma warning restore CA2000 // Dispose objects before losing scope
 
         ///<inheritdoc/>
         public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()

Original file line number	Diff line number	Diff line change
`@@ -136,6 +136,7 @@ public async ValueTask<V> CreateValueAsync<TFactory>(K key, TFactory valueFactor`
`136`	`136`	`return await synchronizedTask.ConfigureAwait(false);`
`137`	`137`	`}`
`138`	`138`
	`139`	`+#pragma warning disable CA2002 // Do not lock on objects with weak identity`
`139`	`140`	`private Task<V> DoubleCheck(Task<V> value)`
`140`	`141`	`{`
`141`	`142`	`// Fast path`
`@@ -155,6 +156,7 @@ private Task<V> DoubleCheck(Task<V> value)`
`155`	`156`
`156`	`157`	`return valueTask;`
`157`	`158`	`}`
	`159`	`+#pragma warning restore CA2002 // Do not lock on objects with weak identity`
`158`	`160`	`}`
`159`	`161`	`}`
`160`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -133,6 +133,7 @@ public override int GetHashCode()`
`133`	`133`	`return ValueIfCreated.GetHashCode();`
`134`	`134`	`}`
`135`	`135`
	`136`	`+#pragma warning disable CA2002 // Do not lock on objects with weak identity`
`136`	`137`	`private class Initializer`
`137`	`138`	`{`
`138`	`139`	`private bool isInitialized;`
`@@ -153,5 +154,6 @@ public V CreateValue<TFactory>(K key, TFactory valueFactory) where TFactory : st`
`153`	`154`	`}`
`154`	`155`	`}`
`155`	`156`	`}`
	`157`	`+#pragma warning restore CA2002 // Do not lock on objects with weak identity`
`156`	`158`	`}`
`157`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -54,11 +54,13 @@ public AtomicFactoryScopedAsyncCache(ICache<K, ScopedAsyncAtomicFactory<K, V>> c`
`54`	`54`	`///<inheritdoc/>`
`55`	`55`	`public ICollection<K> Keys => AtomicEx.FilterKeys<K, ScopedAsyncAtomicFactory<K, V>>(this.cache, v => v.IsScopeCreated);`
`56`	`56`
	`57`	`+#pragma warning disable CA2000 // Dispose objects before losing scope`
`57`	`58`	`///<inheritdoc/>`
`58`	`59`	`public void AddOrUpdate(K key, V value)`
`59`	`60`	`{`
`60`	`61`	`this.cache.AddOrUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));`
`61`	`62`	`}`
	`63`	`+#pragma warning restore CA2000 // Dispose objects before losing scope`
`62`	`64`
`63`	`65`	`///<inheritdoc/>`
`64`	`66`	`public void Clear()`
`@@ -129,11 +131,13 @@ public bool TryRemove(K key)`
`129`	`131`	`return this.cache.TryRemove(key);`
`130`	`132`	`}`
`131`	`133`
	`134`	`+#pragma warning disable CA2000 // Dispose objects before losing scope`
`132`	`135`	`///<inheritdoc/>`
`133`	`136`	`public bool TryUpdate(K key, V value)`
`134`	`137`	`{`
`135`	`138`	`return this.cache.TryUpdate(key, new ScopedAsyncAtomicFactory<K, V>(value));`
`136`	`139`	`}`
	`140`	`+#pragma warning restore CA2000 // Dispose objects before losing scope`
`137`	`141`
`138`	`142`	`///<inheritdoc/>`
`139`	`143`	`public IEnumerator<KeyValuePair<K, Scoped<V>>> GetEnumerator()`
Original file line number	Diff line number	Diff line change
`@@ -182,6 +182,7 @@ public async ValueTask<Scoped<V>> CreateScopeAsync<TFactory>(K key, TFactory val`
`182`	`182`	`return await synchronizedTask.ConfigureAwait(false);`
`183`	`183`	`}`
`184`	`184`
	`185`	`+#pragma warning disable CA2002 // Do not lock on objects with weak identity`
`185`	`186`	`private Task<Scoped<V>> DoubleCheck(Task<Scoped<V>> value)`
`186`	`187`	`{`
`187`	`188`	`// Fast path`
`@@ -201,6 +202,7 @@ private Task<Scoped<V>> DoubleCheck(Task<Scoped<V>> value)`
`201`	`202`
`202`	`203`	`return task;`
`203`	`204`	`}`
	`205`	`+#pragma warning restore CA2002 // Do not lock on objects with weak identity`
`204`	`206`
`205`	`207`	`// <remarks>`
`206`	`208`	`// Let's say there are 2 threads, A and B:`
Original file line number	Diff line number	Diff line change
`@@ -156,6 +156,7 @@ public void Dispose()`
`156`	`156`	`scope.Dispose();`
`157`	`157`	`}`
`158`	`158`
	`159`	`+#pragma warning disable CA2002 // Do not lock on objects with weak identity`
`159`	`160`	`private class Initializer`
`160`	`161`	`{`
`161`	`162`	`private bool isInitialized;`
`@@ -196,5 +197,6 @@ public Scoped<V> TryCreateDisposedScope()`
`196`	`197`	`}`
`197`	`198`	`}`
`198`	`199`	`}`
	`200`	`+#pragma warning restore CA2002 // Do not lock on objects with weak identity`
`199`	`201`	`}`
`200`	`202`	`}`