cleanup code

Author: ssg

.editorconfig

@@ -131,6 +131,7 @@ csharp_style_allow_blank_line_after_colon_in_constructor_initializer_experimenta
 csharp_style_allow_blank_line_after_token_in_conditional_expression_experimental = true:silent
 csharp_style_allow_blank_line_after_token_in_arrow_expression_clause_experimental = true:silent
 csharp_style_prefer_extended_property_pattern = true:suggestion
+dotnet_diagnostic.SA1400.severity = silent
 
 [*.vb]
 #### Naming styles ####

benchmark/Program.cs

@@ -6,6 +6,6 @@ class Program
 {
     public static void Main()
     {
-        BenchmarkRunner.Run<BenchmarkSuite>();
+        _ = BenchmarkRunner.Run<BenchmarkSuite>();
     }
 }

src/MurmurHash3.cs

@@ -283,13 +283,13 @@ public static byte[] Hash128(ReadOnlySpan<byte> buffer, uint seed)
     static byte[] makeBytes(ulong h1, ulong h2)
     {
         var result = new byte[16];
-        BitConverter.TryWriteBytes(result, h1);
-        BitConverter.TryWriteBytes(result.AsSpan()[8..], h2);
+        _ = BitConverter.TryWriteBytes(result, h1);
+        _ = BitConverter.TryWriteBytes(result.AsSpan()[8..], h2);
         return result;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void round32(ref uint value, ref uint hash)
+    static void round32(ref uint value, ref uint hash)
     {
         const uint c1 = 0xcc9e2d51;
         const uint c2 = 0x1b873593;
@@ -301,7 +301,7 @@ static void round32(ref uint value, ref uint hash)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void round128(
+    static void round128(
         ref ulong k,
         ref ulong h,
         ulong c1,
@@ -321,7 +321,7 @@ static void round128(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void fmix64(ref ulong h)
+    static void fmix64(ref ulong h)
     {
         h ^= h >> 33;
         h *= 0xff51afd7ed558ccdUL;
@@ -331,7 +331,7 @@ static void fmix64(ref ulong h)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void tailRound128(ref ulong k, ref ulong h, ulong c1, ulong c2, int rot)
+    static void tailRound128(ref ulong k, ref ulong h, ulong c1, ulong c2, int rot)
     {
         k *= c1;
         k = Bits.RotateLeft(k, rot);

src/SipHash24.cs

@@ -180,14 +180,14 @@ public static ulong Hash64(ReadOnlySpan<byte> buffer, ReadOnlySpan<byte> key)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void sipRoundC(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
+    static void sipRoundC(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     {
         sipRound(ref v0, ref v1, ref v2, ref v3);
         sipRound(ref v0, ref v1, ref v2, ref v3);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void sipRoundD(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
+    static void sipRoundD(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     {
         sipRound(ref v0, ref v1, ref v2, ref v3);
         sipRound(ref v0, ref v1, ref v2, ref v3);
@@ -196,7 +196,7 @@ static void sipRoundD(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void sipRound(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
+    static void sipRound(ref ulong v0, ref ulong v1, ref ulong v2, ref ulong v3)
     {
         v0 += v1;
         v1 = Bits.RotateLeft(v1, 13);

src/XXHash.cs

@@ -215,13 +215,13 @@ public static ulong Hash64(Stream stream, ulong seed = 0)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static (ulong Acc1, ulong Acc2, ulong Acc3, ulong Acc4) initAccumulators64(ulong seed)
+    static (ulong Acc1, ulong Acc2, ulong Acc3, ulong Acc4) initAccumulators64(ulong seed)
     {
         return (seed + prime64v1 + prime64v2, seed + prime64v2, seed, seed - prime64v1);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static ulong processStripe64(
+    static ulong processStripe64(
         ReadOnlySpan<byte> buf,
         ref ulong acc1,
         ref ulong acc2,
@@ -246,14 +246,14 @@ static ulong processStripe64(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void processLane64(ref ulong accn, ReadOnlySpan<byte> buf)
+    static void processLane64(ref ulong accn, ReadOnlySpan<byte> buf)
     {
         ulong lane = Bits.ToUInt64(buf);
         accn = round64(accn, lane);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static ulong processRemaining64(
+    static ulong processRemaining64(
         ReadOnlySpan<byte> remaining,
         ulong acc)
     {
@@ -286,7 +286,7 @@ static ulong processRemaining64(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static ulong avalanche64(ulong acc)
+    static ulong avalanche64(ulong acc)
     {
         acc ^= acc >> 33;
         acc *= prime64v2;
@@ -297,29 +297,29 @@ static ulong avalanche64(ulong acc)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static ulong round64(ulong accn, ulong lane)
+    static ulong round64(ulong accn, ulong lane)
     {
         accn += lane * prime64v2;
         return Bits.RotateLeft(accn, 31) * prime64v1;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void mergeAccumulator64(ref ulong acc, ulong accn)
+    static void mergeAccumulator64(ref ulong acc, ulong accn)
     {
         acc ^= round64(0, accn);
         acc *= prime64v1;
         acc += prime64v4;
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static (uint Acc1, uint Acc2, uint Acc3, uint Acc4) initAccumulators32(
+    static (uint Acc1, uint Acc2, uint Acc3, uint Acc4) initAccumulators32(
         uint seed)
     {
         return (seed + prime32v1 + prime32v2, seed + prime32v2, seed, seed - prime32v1);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static uint processStripe32(
+    static uint processStripe32(
         ReadOnlySpan<byte> buf,
         ref uint acc1,
         ref uint acc2,
@@ -338,14 +338,14 @@ static uint processStripe32(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static void processLane32(ReadOnlySpan<byte> buf, ref uint accn)
+    static void processLane32(ReadOnlySpan<byte> buf, ref uint accn)
     {
         uint lane = Bits.ToUInt32(buf);
         accn = round32(accn, lane);
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static uint processRemaining32(
+    static uint processRemaining32(
         ReadOnlySpan<byte> remaining,
         uint acc)
     {
@@ -369,7 +369,7 @@ static uint processRemaining32(
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static uint round32(uint accn, uint lane)
+    static uint round32(uint accn, uint lane)
     {
         accn += lane * prime32v2;
         accn = Bits.RotateLeft(accn, 13);
@@ -378,7 +378,7 @@ static uint round32(uint accn, uint lane)
     }
 
     [MethodImpl(MethodImplOptions.AggressiveInlining)]
-static uint avalanche32(uint acc)
+    static uint avalanche32(uint acc)
     {
         acc ^= acc >> 15;
         acc *= prime32v2;

test/ChecksumTest.cs

@@ -11,6 +11,6 @@ public class ChecksumTest
     [Test]
     public void Test()
     {
-        Checksum.Hash32(array.AsSpan());
+        Assert.DoesNotThrow(() => Checksum.Hash32(array.AsSpan()));
     }
 }

test/SipHash24Test.cs

@@ -126,14 +126,14 @@ public async Task Hash64Async_TestVectors()
     public void Hash64Async_InvalidKeyLength_Throws()
     {
         using var stream = new MemoryStream([]);
-        Assert.ThrowsAsync<ArgumentException>(async () => await SipHash24.Hash64Async(stream, new byte[15]));
+        _ = Assert.ThrowsAsync<ArgumentException>(async () => await SipHash24.Hash64Async(stream, new byte[15]));
     }
 
     [Test]
     public void Hash64_Stream_InvalidKeyLength_Throws()
     {
         using var stream = new MemoryStream([]);
-        Assert.Throws<ArgumentException>(() => SipHash24.Hash64(stream, new byte[15]));
+        _ = Assert.Throws<ArgumentException>(() => SipHash24.Hash64(stream, new byte[15]));
     }
 
     static byte[] getIncrementalBuffer(int i)
@@ -154,6 +154,6 @@ public void Hash64_InvalidKeyLength_Throws(int keyLength)
     {
         var invalidKey = new byte[keyLength];
         var buffer = Array.Empty<byte>();
-        Assert.Throws<ArgumentException>(() => SipHash24.Hash64(buffer, invalidKey));
+        _ = Assert.Throws<ArgumentException>(() => SipHash24.Hash64(buffer, invalidKey));
     }
 }